metasploit-model 0.24.1-java

data/spec/app/models/metasploit/model/search/operation/string_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe Metasploit::Model::Search::Operation::String do
+  context 'validation' do
+    it { should validate_presence_of(:value) }
+  end
+
+  it_should_behave_like 'Metasploit::Model::Search::Operation::String::Value'
+end

data/spec/app/models/metasploit/model/search/operation/union_spec.rb

@@ -0,0 +1,124 @@
+require 'spec_helper'
+
+describe Metasploit::Model::Search::Operation::Union do
+  subject(:union) do
+    described_class.new
+  end
+
+  it { should be_a Metasploit::Model::Search::Operation::Base }
+
+  context 'validations' do
+    context 'children' do
+      it { should ensure_length_of(:children).is_at_least(1).with_short_message('is too short (minimum is 1 child)') }
+
+      context '#children_valid' do
+        subject(:children_valid) do
+          union.send(:children_valid)
+        end
+
+        #
+        # let
+        #
+
+        let(:error) do
+          I18n.translate!(:'errors.messages.invalid')
+        end
+
+        let(:union) do
+          described_class.new(
+              children: children
+          )
+        end
+
+        context 'with children' do
+          #
+          # lets
+          #
+
+          let(:children) do
+            Array.new(2) { |i|
+              double("Child #{i}")
+            }
+          end
+
+          #
+          # Callbacks
+          #
+
+          context 'with all valid' do
+            before(:each) do
+              children.each do |child|
+                child.stub(valid?: true)
+              end
+            end
+
+            it 'does not add error on :children' do
+              union.valid?
+
+              union.errors[:children].should_not include(error)
+            end
+          end
+
+          context 'with later valid' do
+            before(:each) do
+              children.first.stub(valid?: false)
+              children.second.stub(valid?: true)
+            end
+
+            it 'does not short-circuit and validates all children' do
+              children.second.should_receive(:valid?).and_return(true)
+
+              children_valid
+            end
+
+            it 'should add error on :children' do
+              union.valid?
+
+              union.errors[:children].should include(error)
+            end
+          end
+        end
+
+        context 'without children' do
+          let(:children) do
+            []
+          end
+
+          it 'does not add error on :children' do
+            union.valid?
+
+            union.errors[:children].should_not include(error)
+          end
+        end
+      end
+    end
+  end
+
+  context '#children' do
+    subject(:children) do
+      union.children
+    end
+
+    context 'default' do
+      it { should == [] }
+    end
+
+    context 'with attribute' do
+      let(:expected_children) do
+        [
+            double('child')
+        ]
+      end
+
+      let(:union) do
+        described_class.new(
+            children: expected_children
+        )
+      end
+
+      it 'is the value passed with :children to #new' do
+        children.should == expected_children
+      end
+    end
+  end
+end

data/spec/app/models/metasploit/model/search/operator/association_spec.rb

@@ -0,0 +1,108 @@
+require 'spec_helper'
+
+describe Metasploit::Model::Search::Operator::Association do
+  it { should be_a Metasploit::Model::Search::Operator::Single }
+
+  context 'validations' do
+    it { should validate_presence_of(:association) }
+    it { should validate_presence_of(:attribute_operator) }
+  end
+
+  context 'delegate :to  => attribute_operator' do
+    let(:association) do
+      FactoryGirl.generate :metasploit_model_search_operator_association_association
+    end
+
+    let(:association_operator) do
+      described_class.new(
+          :association => association,
+          :attribute_operator => attribute_operator
+      )
+    end
+
+    let(:attribute_operator) do
+      double('Metasploit::Model::Search::Operator::Attribute')
+    end
+
+    context '#attribute' do
+      subject(:attribute) do
+        association_operator.attribute
+      end
+
+      it 'should delegate to #attribute_operator' do
+        attribute_operator.should_receive(:attribute)
+
+        attribute
+      end
+    end
+
+    context '#attribute_set' do
+      subject(:attribute_set) do
+        association_operator.attribute_set
+      end
+
+      it 'should delegate to #attribute_operator' do
+        attribute_operator.should_receive(:attribute_set)
+
+        attribute_set
+      end
+    end
+
+    context '#help' do
+      subject(:help) do
+        association_operator.help
+      end
+
+      it 'should delegate to #attribute_operator' do
+        attribute_operator.should_receive(:help)
+
+        help
+      end
+    end
+
+    context '#type' do
+      subject(:type) do
+        association_operator.type
+      end
+
+      it 'should delegate to #attribute_operator' do
+        attribute_operator.should_receive(:type)
+
+        type
+      end
+    end
+  end
+
+  context '#name' do
+    subject(:name) do
+      association_operator.name
+    end
+
+    let(:association) do
+      FactoryGirl.generate :metasploit_model_search_operator_association_association
+    end
+
+    let(:association_operator) do
+      described_class.new(
+          :association => association,
+          :attribute_operator => attribute_operator
+      )
+    end
+
+    let(:attribute) do
+      FactoryGirl.generate :metasploit_model_search_operator_attribute_attribute
+    end
+
+    let(:attribute_operator) do
+      Metasploit::Model::Search::Operator::Attribute.new(
+          :attribute => attribute
+      )
+    end
+
+    it { should be_a Symbol }
+
+    it 'should be <association>.<attribute>' do
+      name.to_s.should == "#{association}.#{attribute}"
+    end
+  end
+end

data/spec/app/models/metasploit/model/search/operator/attribute_spec.rb

@@ -0,0 +1,104 @@
+require 'spec_helper'
+
+describe Metasploit::Model::Search::Operator::Attribute do
+  it { should be_a Metasploit::Model::Search::Operator::Single }
+
+  context 'CONSTANTS' do
+    context 'TYPES' do
+      subject(:types) do
+        described_class::TYPES
+      end
+
+      it { should include(:boolean) }
+      it { should include(:date) }
+      it {
+        should include(
+                   {
+                       set: :integer
+                   }
+               )
+      }
+      it {
+        should include(
+                   {
+                       set: :string
+                   }
+               )
+      }
+      it { should include(:integer) }
+      it { should include(:string) }
+    end
+  end
+
+  context 'validations' do
+    it { should validate_presence_of(:attribute) }
+    it { should ensure_inclusion_of(:type).in_array(described_class::TYPES) }
+  end
+
+  context '#attribute_enumerable' do
+    subject(:attribute_set) do
+      attribute_operator.attribute_set
+    end
+
+    let(:attribute) do
+      :set_attribute
+    end
+
+    let(:attribute_operator) do
+      described_class.new(
+          attribute: attribute,
+          klass: klass
+      )
+    end
+
+    let(:expected_attribute_set) do
+      Set.new [:a, :b]
+    end
+
+    let(:klass) do
+      Class.new.tap { |klass|
+        expected_attribute_set = self.expected_attribute_set
+
+        klass.define_singleton_method("#{attribute}_set") do
+          expected_attribute_set
+        end
+      }
+    end
+
+    context 'with responds to #attribute_set_method_name' do
+      let(:expected_attribute_set) do
+        Set.new(
+            [
+                :a,
+                :b,
+                :c
+            ]
+        )
+      end
+
+      it 'should be #klass #<attribute>_set' do
+        attribute_set.should == expected_attribute_set
+      end
+    end
+  end
+
+  context '#name' do
+    subject(:name) do
+      attribute_operator.name
+    end
+
+    let(:attribute) do
+      FactoryGirl.generate :metasploit_model_search_operator_attribute_attribute
+    end
+
+    let(:attribute_operator) do
+      described_class.new(
+          :attribute => attribute
+      )
+    end
+
+    it 'should be #attribute' do
+      name.should == attribute
+    end
+  end
+end

data/spec/app/models/metasploit/model/search/operator/base_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe Metasploit::Model::Search::Operator::Base do
+  subject(:operator) do
+    described_class.new
+  end
+
+  it_should_behave_like 'Metasploit::Model::Search::Operator::Help' do
+    let(:operator) do
+      described_class.new(klass: klass)
+    end
+
+    before(:each) do
+      # have to stub since it's not implemented on base
+      operator.stub(name: name)
+    end
+  end
+
+  context 'validations' do
+    it { should validate_presence_of(:klass) }
+  end
+
+  context '#name' do
+    subject(:name) do
+      operator.name
+    end
+
+    it 'should not be implemented' do
+      expect {
+        name
+      }.to raise_error(NotImplementedError)
+    end
+  end
+end

data/spec/app/models/metasploit/model/search/operator/delegation_spec.rb

@@ -0,0 +1,108 @@
+require 'spec_helper'
+
+describe Metasploit::Model::Search::Operator::Delegation do
+  subject(:operator) do
+    described_class.new(
+        :klass => klass
+    )
+  end
+
+  let(:klass) do
+    Class.new
+  end
+
+  it { should be_a Metasploit::Model::Search::Operator::Base }
+
+  context 'operator_name' do
+    subject(:operator_name) do
+      subclass.operator_name
+    end
+
+    let(:subclass) do
+      Class.new(described_class)
+    end
+
+    context 'with namespace' do
+      let(:base_name) do
+        'Demodulized'
+      end
+
+      before(:each) do
+        stub_const("Namespace::#{base_name}", subclass)
+      end
+
+      it 'should remove namespace' do
+        operator_name.should == base_name.downcase.to_sym
+      end
+    end
+
+    context 'with Camelized' do
+      before(:each) do
+        stub_const("CamelCase", subclass)
+      end
+
+      it 'should convert name to underscore' do
+        operator_name.should == :camel_case
+      end
+    end
+  end
+
+  context '#operator' do
+    subject(:named_operator) do
+      operator.send(:operator, formatted_operator)
+    end
+
+    let(:formatted_operator) do
+      double('Formatted Operator', :to_sym => :formatted_operator)
+    end
+
+    let(:search_operator) do
+      double('Search Operator')
+    end
+
+    let(:search_operator_by_name) do
+      {
+          formatted_operator.to_sym => search_operator
+      }
+    end
+
+    before(:each) do
+      klass.stub(:search_operator_by_name => search_operator_by_name)
+    end
+
+    it 'should convert formatted_operator to Symbol' do
+      formatted_operator.should_receive(:to_sym)
+
+      named_operator
+    end
+
+    it 'should look up operator name in search_operator_by_name of #klass' do
+      named_operator.should == search_operator
+    end
+
+    context 'with name not in klass.search_operator_by_name' do
+      let(:search_operator_by_name) do
+        {}
+      end
+
+      it 'should raise ArgumentError' do
+        expect {
+          named_operator
+        }.to raise_error(ArgumentError, "No operator with name #{formatted_operator.to_sym.inspect} on #{klass}")
+      end
+    end
+  end
+
+  context '#name' do
+    subject(:name) do
+      operator.name
+    end
+
+    it 'should delegate to operator_name' do
+      operator_name = double('Operator Name')
+      operator.class.stub(:operator_name => operator_name)
+
+      name.should == operator_name
+    end
+  end
+end