metasploit-model 0.24.1-java

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

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe Metasploit::Model::Search::Operator::Null do
+  subject(:operator) do
+    described_class.new
+  end
+
+  it { should be_a Metasploit::Model::Search::Operator::Single }
+
+  context 'validations' do
+    context 'name' do
+      let(:error) do
+        I18n.translate('metasploit.model.errors.models.metasploit/model/search/operator/null.attributes.name.unknown')
+      end
+
+      before(:each) do
+        operator.valid?
+      end
+
+      it 'should record error' do
+        operator.errors[:name].should include(error)
+      end
+    end
+  end
+
+  context '#type' do
+    subject(:type) do
+      operator.type
+    end
+
+    it { should be_nil }
+  end
+
+  context '#operation_class' do
+    subject(:operation_class) do
+      operator.send(:operation_class)
+    end
+
+    it { should == Metasploit::Model::Search::Operation::Null }
+  end
+end

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

@@ -0,0 +1,327 @@
+require 'spec_helper'
+
+describe Metasploit::Model::Search::Operator::Single do
+  subject(:operator) do
+    described_class.new
+  end
+
+  it { should be_a Metasploit::Model::Search::Operator::Base }
+
+  context 'CONSTANTS' do
+    context 'MODULE_SEPARATOR' do
+      subject(:module_separator) do
+        described_class::MODULE_SEPARATOR
+      end
+
+      it { should == '::' }
+    end
+
+    context 'OPERATION_NAMESPACE_NAME' do
+      subject(:operation_namespace_name) do
+        described_class::OPERATION_NAMESPACE_NAME
+      end
+
+      it { should == 'Metasploit::Model::Search::Operation' }
+    end
+  end
+
+  context 'constant_name' do
+    subject(:constant_name) do
+      described_class.constant_name(type)
+    end
+
+    context 'with Hash' do
+      context 'with zero entries' do
+        let(:type) do
+          {}
+        end
+
+        specify {
+          expect {
+            constant_name
+          }.to raise_error(ArgumentError, "Cannot destructure a Hash without entries")
+        }
+      end
+
+      context 'with one entry' do
+        let(:key) do
+          :enum
+        end
+
+        let(:key_constant_name) do
+          'Enum'
+        end
+
+        let(:type) do
+          {
+              key => value
+          }
+        end
+
+        let(:value) do
+          :integer
+        end
+
+        let(:value_constant_name) do
+          'Integer'
+        end
+
+        it 'should be the constant_name of the key and value separated by MODULE_SEPARATOR' do
+          constant_name.should == "#{key_constant_name}#{described_class::MODULE_SEPARATOR}#{value_constant_name}"
+        end
+      end
+
+      context 'with multiple entries' do
+        let(:type) do
+          {
+              key1: :value1,
+              key2: :value2
+          }
+        end
+
+        specify {
+          expect {
+            constant_name
+          }.to raise_error(ArgumentError, 'Cannot destructure a Hash with multiple entries')
+        }
+      end
+    end
+
+    context 'with Symbol' do
+      let(:type) do
+        :integer
+      end
+
+      it 'should constantize string version of Symbol' do
+        constant_name.should == 'Integer'
+      end
+    end
+
+    context 'without Hash or Symbol' do
+      let(:type) do
+        nil
+      end
+
+      specify {
+        expect {
+          constant_name
+        }.to raise_error(ArgumentError, "Can only convert Hashes and Symbols to constant names, not #{type.inspect}")
+      }
+    end
+  end
+
+  context '#operate_on' do
+    subject(:operate_on) do
+      operator.operate_on(formatted_value)
+    end
+
+    let(:formatted_value) do
+      'value'
+    end
+
+    let(:operation_class) do
+      double('Operation Class')
+    end
+
+    before(:each) do
+      operator.stub(:operation_class => operation_class)
+    end
+
+    it 'should call new on #operation_class' do
+      operation_class.should_receive(:new).with(:value => formatted_value, :operator => operator)
+
+      operate_on
+    end
+
+    it 'should return instance of #operation_class' do
+      operation = double('Operation')
+      operation_class.stub(:new => operation)
+
+      operate_on.should == operation
+    end
+  end
+
+  context "#operation_class" do
+    subject(:operation_class) do
+      operator.send(:operation_class)
+    end
+
+    before(:each) do
+      operator.stub(:type => type)
+    end
+
+    context 'type' do
+      context 'with :boolean' do
+        let(:type) do
+          :boolean
+        end
+
+        it { should == Metasploit::Model::Search::Operation::Boolean }
+      end
+
+      context 'with :date' do
+        let(:type) do
+          :date
+        end
+
+        it { should == Metasploit::Model::Search::Operation::Date }
+      end
+
+      context 'with set: :integer' do
+        let(:type) do
+          {
+              set: :integer
+          }
+        end
+
+        it { should == Metasploit::Model::Search::Operation::Set::Integer }
+      end
+
+      context 'with set: :string' do
+        let(:type) do
+          {
+              set: :string
+          }
+        end
+
+        it { should == Metasploit::Model::Search::Operation::Set::String }
+      end
+
+      context 'with :integer' do
+        let(:type) do
+          :integer
+        end
+
+        it { should == Metasploit::Model::Search::Operation::Integer }
+      end
+
+      context 'with :string' do
+        let(:type) do
+          :string
+        end
+
+        it { should == Metasploit::Model::Search::Operation::String }
+      end
+
+      context 'with nil' do
+        let(:name) do
+          :single
+        end
+
+        let(:type) do
+          nil
+        end
+
+        before(:each) do
+          operator.stub(:name => name)
+        end
+
+        it 'should raise ArgumentError' do
+          expect {
+            operation_class
+          }.to raise_error(
+                   ArgumentError,
+                   "#{described_class}#operation_class_name cannot be derived for #{name} operator because its type is nil")
+        end
+      end
+    end
+  end
+
+  context '#operation_class_name' do
+    subject(:operation_class_name) do
+      operator.send(:operation_class_name)
+    end
+
+    before(:each) do
+      operator.stub(:type => type)
+    end
+
+    context 'type' do
+      context 'with :boolean' do
+        let(:type) do
+          :boolean
+        end
+
+        it { should == 'Metasploit::Model::Search::Operation::Boolean' }
+      end
+
+      context 'with :date' do
+        let(:type) do
+          :date
+        end
+
+        it { should == 'Metasploit::Model::Search::Operation::Date' }
+      end
+
+      context 'with set: :integer' do
+        let(:type) do
+          {
+              set: :integer
+          }
+        end
+
+        it { should == 'Metasploit::Model::Search::Operation::Set::Integer' }
+      end
+
+      context 'with set: :string' do
+        let(:type) do
+          {
+              set: :string
+          }
+        end
+
+        it { should == 'Metasploit::Model::Search::Operation::Set::String' }
+      end
+
+      context 'with :integer' do
+        let(:type) do
+          :integer
+        end
+
+        it { should == 'Metasploit::Model::Search::Operation::Integer' }
+      end
+
+      context 'with :string' do
+        let(:type) do
+          :string
+        end
+
+        it { should == 'Metasploit::Model::Search::Operation::String' }
+      end
+
+      context 'with nil' do
+        let(:name) do
+          :single
+        end
+
+        let(:type) do
+          nil
+        end
+
+        before(:each) do
+          operator.stub(:name => name)
+        end
+
+        it 'should raise ArgumentError' do
+          expect {
+            operation_class_name
+          }.to raise_error(
+                   ArgumentError,
+                   "#{described_class}#operation_class_name cannot be derived for #{name} operator because its type is nil")
+        end
+      end
+    end
+  end
+
+  context '#type' do
+    subject(:type) do
+      operator.type
+    end
+
+    it 'should not be implemented' do
+      expect {
+        type
+      }.to raise_error(NotImplementedError)
+    end
+  end
+end

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

@@ -0,0 +1,92 @@
+require 'spec_helper'
+
+describe Metasploit::Model::Search::Operator::Union do
+  subject(:operator) do
+    described_class.new
+  end
+
+  let(:formatted_value) do
+    'formatted_value'
+  end
+
+  context '#children' do
+    subject(:children) do
+      operator.children(formatted_value)
+    end
+
+    it 'should be abstract' do
+      expect {
+        children
+      }.to raise_error(NotImplementedError)
+    end
+  end
+
+  context '#operate_on' do
+    subject(:operation) do
+      operator.operate_on(formatted_value)
+    end
+
+    #
+    # lets
+    #
+
+    let(:children) do
+      [
+          invalid_child,
+          valid_child
+      ]
+    end
+
+    let(:valid_child) do
+      double('Valid Child', valid?: true)
+    end
+
+    let(:invalid_child) do
+      double('Invalid Child', valid?: false)
+    end
+
+    #
+    # Callbacks
+    #
+
+    before(:each) do
+      operator.stub(:children => children)
+    end
+
+    it { should be_a Metasploit::Model::Search::Operation::Union }
+
+    context 'children' do
+      subject(:operation_children) do
+        operation.children
+      end
+
+      it 'rejected invalid children' do
+        expect(operation_children).not_to include(invalid_child)
+      end
+
+      it 'includes valid children' do
+        expect(operation_children).to include(valid_child)
+      end
+    end
+
+    context 'operator' do
+      subject(:operation_operator) do
+        operation.operator
+      end
+
+      it 'should be the operator itself' do
+        operation_operator.should == operator
+      end
+    end
+
+    context 'value' do
+      subject(:value) do
+        operation.value
+      end
+
+      it 'should be formatted value' do
+        value.should == formatted_value
+      end
+    end
+  end
+end