metasploit-model 0.24.1-java

data/spec/support/shared/examples/metasploit/model/search/operation/string/value.rb

@@ -0,0 +1,53 @@
+shared_examples_for 'Metasploit::Model::Search::Operation::String::Value' do
+  let(:operation_class) do
+    described_class
+  end
+
+  context '#class' do
+    subject do
+      operation_class
+    end
+
+    it { should include Metasploit::Model::Search::Operation::String::Value }
+  end
+
+  context '#value' do
+    subject(:value) do
+      operation.value
+    end
+
+    let(:operation) do
+      operation_class.new(:value => formatted_value)
+    end
+
+    context 'with Integer' do
+      let(:formatted_value) do
+        5
+      end
+
+      it 'should convert to String' do
+        value.should == '5'
+      end
+    end
+
+    context 'with String' do
+      let(:formatted_value) do
+        'a string'
+      end
+
+      it 'should pass through String' do
+        value.should == formatted_value
+      end
+    end
+
+    context 'with Symbol' do
+      let(:formatted_value) do
+        :a_symbol
+      end
+
+      it 'should convert to String' do
+        value.should == 'a_symbol'
+      end
+    end
+  end
+end

data/spec/support/shared/examples/metasploit/model/search/operator/help.rb

@@ -0,0 +1,134 @@
+shared_examples_for 'Metasploit::Model::Search::Operator::Help' do
+  context '#help' do
+    subject(:help) do
+      operator.help
+    end
+
+    let(:help_template) do
+      "%{name} operator for searching %{model}"
+    end
+
+    let(:klass) do
+      Class.new(Metasploit::Model::Base)
+    end
+
+    let(:model) do
+      'Klass'
+    end
+
+    let(:name) do
+      'operator_name'
+    end
+
+    before(:each) do
+      # klass needs to be named or model_name will fail.
+      stub_const('Klass', klass)
+      # since missing translations raise exceptions, and there is no translation for klass, have to stub out.
+      klass.model_name.stub(:human).and_return(model)
+
+      backend = I18n.backend
+
+      unless backend.initialized?
+        backend.send(:init_translations)
+      end
+
+      translations_by_locale = I18n.backend.send(:translations)
+      english_translations = translations_by_locale.fetch(:en)
+      metasploit_translations = english_translations.fetch(:metasploit)
+      @metasploit_model_translations = metasploit_translations.fetch(:model)
+      ancestors_translations = @metasploit_model_translations.fetch(:ancestors)
+
+      @original_ancestors_translations = ancestors_translations.dup
+
+      ancestors_translations.merge!(
+          klass.model_name.i18n_key => {
+              search: {
+                  operator: {
+                      names: {
+                          name.to_sym => {
+                              help: help_template
+                          }
+                      }
+                  }
+              }
+          }
+
+      )
+    end
+
+    after(:each) do
+      @metasploit_model_translations[:ancestors] = @original_ancestors_translations
+    end
+
+    it 'should use #klass #i18n_scope to lookup translations specific to the #klass or one of its ancestors' do
+      klass.should_receive(:i18n_scope).and_call_original
+
+      help
+    end
+
+    it 'should lookup ancestors of #klass to find translations specific to #klass or its ancestors' do
+      klass.should_receive(:lookup_ancestors).and_call_original
+
+      help
+    end
+
+    it 'should use #class #i18n_scope to lookup translations specific to the operator class or one of its ancestors' do
+      operator.class.should_receive(:i18n_scope)
+
+      help
+    end
+
+    it 'should lookup ancestors of the operator class to find translations specific to the operator class or one of its ancestors' do
+      operator.class.should_receive(:lookup_ancestors).and_return([])
+
+      help
+    end
+
+    it "should pass #klass translation key for operator with the given name as the primary translation key" do
+      I18n.should_receive(:translate).with(
+          :"#{klass.i18n_scope}.ancestors.#{klass.model_name.i18n_key}.search.operator.names.#{name}.help",
+          anything
+      )
+
+      help
+    end
+
+    it 'should pass other translation keys as default option' do
+      I18n.should_receive(:translate) do |_key, options|
+        options.should be_a Hash
+
+        default = options[:default]
+
+        default.should be_an Array
+
+        default.all? { |key|
+          key.is_a? Symbol
+        }.should be_true
+      end
+
+      help
+    end
+
+    it 'should pass #name of operator as name option' do
+      I18n.should_receive(:translate).with(
+          anything,
+          hash_including(name: name)
+      )
+
+      help
+    end
+
+    it 'should pass the human model name of #klass as model option' do
+      I18n.should_receive(:translate).with(
+          anything,
+          hash_including(model: klass.model_name.human)
+      )
+
+      help
+    end
+
+    it 'should be translated correctly' do
+      help.should == help_template % { model: model, name: name }
+    end
+  end
+end

data/spec/support/shared/examples/metasploit/model/translation.rb

@@ -0,0 +1,37 @@
+shared_examples_for 'Metasploit::Model::Translation' do |options={}|
+  options.assert_valid_keys(:metasploit_model_ancestor)
+
+  metasploit_model_ancestor = options.fetch(:metasploit_model_ancestor)
+
+  it 'should include Metasploit::Model::Translation' do
+    base_class.should include Metasploit::Model::Translation
+  end
+
+  unless metasploit_model_ancestor.is_a? Class
+    context metasploit_model_ancestor do
+      context "dependencies" do
+        subject(:dependencies) do
+          metasploit_model_ancestor.instance_variable_get :@_dependencies
+        end
+
+        it { should include Metasploit::Model::Translation }
+      end
+    end
+  end
+
+  context 'i18n_scope' do
+    subject(:i18n_scope) do
+      base_class.i18n_scope
+    end
+
+    it { should == 'metasploit.model' }
+  end
+
+  context 'lookup_ancestors' do
+    subject(:lookup_ancestors) do
+      base_class.lookup_ancestors
+    end
+
+    it { should include metasploit_model_ancestor }
+  end
+end

data/spec/support/shared/examples/search/query.rb

@@ -0,0 +1,43 @@
+shared_examples_for 'search query' do |options={}|
+  options.assert_valid_keys(:formatted_operator)
+
+  formatted_operator = options.fetch(:formatted_operator)
+
+  context "with #{formatted_operator}" do
+    subject(:query) do
+      Metasploit::Model::Search::Query.new(
+          :formatted => formatted,
+          :klass => base_class
+      )
+    end
+
+    let(:formatted) do
+      "#{formatted_operator}:\"#{formatted_value}\""
+    end
+
+    let(:formatted_value) do
+      "formatted_value"
+    end
+
+    context 'operations' do
+      subject(:operations) do
+        query.operations
+      end
+
+      context 'operator with matching name' do
+        subject(:operator) do
+          operation.operator
+        end
+
+        let(:operation) do
+          operations.find { |operation|
+            operation.operator.name == formatted_operator.to_sym
+          }
+        end
+
+        it { should_not be_nil }
+        it { should be_valid }
+      end
+    end
+  end
+end

data/spec/support/shared/examples/search/query/metasploit/model/search/operator/deprecated/app.rb

@@ -0,0 +1,44 @@
+shared_examples_for 'search query with Metasploit::Model::Search::Operator::Deprecated::App' do
+  context 'with app' do
+    subject(:query) do
+      Metasploit::Model::Search::Query.new(
+          :formatted => formatted,
+          :klass => base_class
+      )
+    end
+
+    let(:formatted) do
+      "app:#{formatted_value}"
+    end
+
+    context 'operations' do
+      subject(:operations) do
+        query.operations
+      end
+
+      context 'stance' do
+        subject(:operation) do
+          operations.find { |operation|
+            operation.operator.name == :stance
+          }
+        end
+
+        context 'with client' do
+          let(:formatted_value) do
+            'client'
+          end
+
+          its(:value) { should == 'passive' }
+        end
+
+        context 'with server' do
+          let(:formatted_value) do
+            'server'
+          end
+
+          its(:value) { should == 'aggressive' }
+        end
+      end
+    end
+  end
+end

data/spec/support/shared/examples/search/query/metasploit/model/search/operator/deprecated/authority.rb

@@ -0,0 +1,60 @@
+shared_examples_for 'search query with Metasploit::Model::Search::Operator::Deprecated::Authority' do |options={}|
+  options.assert_valid_keys(:formatted_operator)
+
+  formatted_operator = options.fetch(:formatted_operator)
+
+  context "with #{formatted_operator}" do
+    subject(:query) do
+      Metasploit::Model::Search::Query.new(
+          :formatted => formatted,
+          :klass => base_class
+      )
+    end
+
+    let(:formatted) do
+      "#{formatted_operator}:\"#{formatted_value}\""
+    end
+
+    let(:formatted_value) do
+      FactoryGirl.generate :metasploit_model_reference_designation
+    end
+
+    context 'operations' do
+      subject(:operations) do
+        query.operations
+      end
+
+      def operation_with_formatted_operator(formatted_operator)
+        operator_name = formatted_operator.to_sym
+
+        operations.find { |operation|
+          operation.operator.name == operator_name
+        }
+      end
+
+      context 'authoritities.abbreviation' do
+        subject(:operation) do
+          operation_with_formatted_operator('authorities.abbreviation')
+        end
+
+        its(:value) { should == formatted_operator }
+      end
+
+      context 'references.designation' do
+        subject(:operation) do
+          operation_with_formatted_operator('references.designation')
+        end
+
+        context 'value' do
+          subject(:value) do
+            operation.value
+          end
+
+          it 'should be formatted value' do
+            value.should == formatted_value
+          end
+        end
+      end
+    end
+  end
+end

data/spec/support/shared/examples/search_association.rb

@@ -0,0 +1,13 @@
+shared_examples_for 'search_association' do |association|
+  context association do
+    let(:association_operators) do
+      base_class.search_operator_by_name.select { |_name, operator|
+        operator.respond_to?(:association) and operator.association == association
+      }
+    end
+
+    it 'should have operators for association' do
+      association_operators.should_not be_empty
+    end
+  end
+end

data/spec/support/shared/examples/search_attribute.rb

@@ -0,0 +1,27 @@
+shared_examples_for 'search_attribute' do |name, options={}|
+  options.assert_valid_keys(:type)
+  type = options.fetch(:type)
+
+  it_should_behave_like 'search_with',
+                        Metasploit::Model::Search::Operator::Attribute,
+                        :attribute => name,
+                        :name => name,
+                        :type => type
+
+  if type.is_a? Hash
+    parent_type, _child_type = type.first
+
+    if parent_type == :set
+      attribute_set_method_name = "#{name}_set"
+
+      context attribute_set_method_name do
+        subject(attribute_set_method_name) do
+          base_class.send(attribute_set_method_name)
+        end
+
+        it { should be_a Set }
+        it { should_not be_empty }
+      end
+    end
+  end
+end

data/spec/support/shared/examples/search_with.rb

@@ -0,0 +1,36 @@
+shared_examples_for 'search_with' do |operation_class, options={}|
+  name = options.fetch(:name)
+
+  context name do
+    subject(:with_operator) do
+      base_class.search_with_operator_by_name[name]
+    end
+
+    it { should be_a operation_class }
+
+    options.each do |key, value|
+      # skip :name since it use used to look up operator, so it's already been checked or with_operator would be `nil`
+      unless key == :name
+        its(key) { should == value }
+      end
+    end
+
+    context 'help' do
+      subject(:help) do
+        with_operator.help
+      end
+
+      context 'with en locale' do
+        around(:each) do |example|
+          I18n.with_locale(:en) do
+            example.run
+          end
+        end
+
+        it 'should have translation' do
+          help.should_not include('translation missing')
+        end
+      end
+    end
+  end
+end