metasploit-model 0.28.0 → 0.29.0

data/spec/app/models/metasploit/model/module/class/spec/template_spec.rb

@@ -1,222 +0,0 @@
-require 'spec_helper'
-
-describe Metasploit::Model::Module::Class::Spec::Template do
-  subject(:template) do
-    described_class.new(
-        module_class: module_class
-    )
-  end
-
-  let(:module_class) do
-    FactoryGirl.build(
-        :dummy_module_class
-    )
-  end
-
-  context 'validations' do
-    it { should validate_presence_of :module_class }
-
-    context '#ancestor_templates_valid' do
-      subject(:ancestor_templates_valid) do
-        template.send(:ancestor_templates_valid)
-      end
-
-      #
-      # let
-      #
-
-      let(:error) do
-        I18n.translate!(:'errors.messages.invalid')
-      end
-
-      #
-      # Callbacks
-      #
-
-      before(:each) do
-        allow(template).to receive(:ancestor_templates).and_return(ancestor_templates)
-      end
-
-      context 'with ancestor_templates' do
-        #
-        # lets
-        #
-
-        let(:ancestor_templates) do
-          Array.new(2) { |i|
-            double("Ancestor Template #{i}")
-          }
-        end
-
-        #
-        # Callbacks
-        #
-
-        context 'with all valid' do
-          before(:each) do
-            ancestor_templates.each do |child|
-              child.stub(valid?: true)
-            end
-          end
-
-          it 'does not add error on :ancestor_templates' do
-            template.valid?
-
-            template.errors[:ancestor_templates].should_not include(error)
-          end
-        end
-
-        context 'with later valid' do
-          before(:each) do
-            ancestor_templates.first.stub(valid?: false)
-            ancestor_templates.second.stub(valid?: true)
-          end
-
-          it 'does not short-circuit and validates all ancestor_templates' do
-            ancestor_templates.second.should_receive(:valid?).and_return(true)
-
-            ancestor_templates_valid
-          end
-
-          it 'should add error on :ancestor_templates' do
-            template.valid?
-
-            template.errors[:ancestor_templates].should include(error)
-          end
-        end
-      end
-
-      context 'without ancestor_templates' do
-        let(:ancestor_templates) do
-          []
-        end
-
-        it 'does not add error on :ancestor_templates' do
-          template.valid?
-
-          template.errors[:ancestor_templates].should_not include(error)
-        end
-      end
-    end
-  end
-
-  context '#ancestor_templates' do
-    subject(:ancestor_templates) do
-      template.ancestor_templates
-    end
-
-    it 'creates Metasploit::Model::Module::Ancestor::Spec::Template for each ancestor in module_class.ancestors' do
-      template_module_ancestors = ancestor_templates.map(&:module_ancestor)
-
-      expect(template_module_ancestors).to match_array(module_class.ancestors)
-    end
-
-    context 'Metasploit::Model::Module::Ancestor::Spec::Template' do
-      context 'locals' do
-        subject(:ancestor_template_locals) do
-          ancestor_templates.map(&:locals)
-        end
-
-        context '[:module_class]' do
-          subject(:local_module_classes) do
-            ancestor_template_locals.collect { |locals|
-              locals[:module_class]
-            }
-          end
-
-          it 'is #module_class' do
-            expect(
-                local_module_classes.all? { |local_module_class|
-                  local_module_class == module_class
-                }
-            ).to be_true
-          end
-        end
-      end
-
-      context 'overwrite' do
-        subject(:overwrites) do
-          ancestor_templates.map(&:overwrite)
-        end
-
-        it 'is true so the the ancestor written templates will be overwritten by the class templates' do
-          expect(
-              overwrites.all? { |overwrite|
-                overwrite == true
-              }
-          ).to be_true
-        end
-      end
-
-      context 'search_pathnames' do
-        subject(:search_pathnames) do
-          ancestor_templates.map(&:search_pathnames)
-        end
-
-        it "has 'module/classes' before 'module/ancestors'" do
-          expect(
-              search_pathnames.all? { |template_search_pathnames|
-                module_classes_index = template_search_pathnames.index(Pathname.new('module/classes'))
-                module_ancestors_index = template_search_pathnames.index(Pathname.new('module/ancestors'))
-
-                module_classes_index < module_ancestors_index
-              }
-          ).to be_true
-        end
-      end
-    end
-  end
-
-  context 'write' do
-    subject(:write) do
-      described_class.write(attributes)
-    end
-
-    context 'with valid' do
-      let(:attributes) do
-        {
-            module_class: module_class
-        }
-      end
-
-      it { should be_true }
-
-      it 'writes template' do
-        # memoize attributes so any other writes besides the one under-test are already run.
-        attributes
-
-        described_class.any_instance.should_receive(:write)
-
-        write
-      end
-    end
-
-    context 'without valid' do
-      let(:attributes) do
-        {}
-      end
-
-      it { should be_false }
-
-      it 'does not write template' do
-        described_class.any_instance.should_not_receive(:write)
-
-        write
-      end
-    end
-  end
-
-  context '#write' do
-    subject(:write) do
-      template.write
-    end
-
-    it 'writes each ancestor template' do
-      template.ancestor_templates.each do |ancestor_template|
-        expect(ancestor_template).to receive(:write)
-      end
-
-      write
-    end
-  end
-end

data/spec/app/models/metasploit/model/module/instance/spec/template_spec.rb

@@ -1,201 +0,0 @@
-require 'spec_helper'
-
-describe Metasploit::Model::Module::Instance::Spec::Template do
-  subject(:template) do
-    described_class.new(
-        module_instance: module_instance
-    )
-  end
-
-  let(:module_instance) do
-    FactoryGirl.build(:dummy_module_instance)
-  end
-
-  context 'validations' do
-    context '#class_template' do
-      subject(:class_template_errors) do
-        template.errors[:class_template]
-      end
-
-      context 'presence' do
-        let(:error) do
-          I18n.translate!('errors.messages.blank')
-        end
-
-        context 'with nil' do
-          before(:each) do
-            allow(template).to receive(:class_template).and_return(nil)
-            template.valid?
-          end
-
-          it { should include error }
-        end
-
-        context 'without nil' do
-          before(:each) do
-            template.valid?
-          end
-
-          it { should_not include error }
-        end
-      end
-
-      context '#class_template_valid' do
-        let(:error) do
-          I18n.translate!('errors.messages.invalid')
-        end
-
-        context 'with #class_template' do
-          context 'with valid' do
-            before(:each) do
-              template.valid?
-            end
-
-            it { should_not include(error) }
-          end
-
-          context 'without valid' do
-            before(:each) do
-              expect(template.class_template).to receive(:valid?).and_return(false)
-              template.valid?
-            end
-
-            it { should include(error) }
-          end
-        end
-
-        context 'without #class_template' do
-          before(:each) do
-            allow(template).to receive(:class_template).and_return(nil)
-            template.valid?
-          end
-
-          it { should_not include(error) }
-        end
-      end
-    end
-
-    it { should validate_presence_of :module_instance }
-  end
-
-  context '#class_template' do
-    subject(:class_template) do
-      template.class_template
-    end
-
-    context 'with #module_instance' do
-      it { should be_a Metasploit::Model::Module::Class::Spec::Template }
-
-      context '#ancestor_templates' do
-        subject(:ancestor_templates) do
-          class_template.ancestor_templates
-        end
-
-        context 'locals' do
-          subject(:ancestor_template_locals) do
-            ancestor_templates.map(&:locals)
-          end
-
-          context '[:module_instance]' do
-            subject(:module_instances) do
-              ancestor_template_locals.collect { |locals|
-                locals[:module_instance]
-              }
-            end
-
-            it 'is #module_instance' do
-              expect(
-                  module_instances.all? { |actual_module_instance|
-                    actual_module_instance == module_instance
-                  }
-              ).to be_true
-            end
-          end
-        end
-
-        context 'search_pathnames' do
-          subject(:search_pathnames) do
-            ancestor_templates.map(&:search_pathnames)
-          end
-
-          it "has 'module/instances', then 'module/classes', then 'module/ancestors'" do
-            search_pathnames.each do |actual_search_pathnames|
-              module_instances_index = actual_search_pathnames.index(Pathname.new('module/instances'))
-              module_classes_index = actual_search_pathnames.index(Pathname.new('module/classes'))
-              module_ancestors_index = actual_search_pathnames.index(Pathname.new('module/ancestors'))
-
-              expect(module_instances_index).to be < module_classes_index
-              expect(module_classes_index).to be < module_ancestors_index
-            end
-          end
-        end
-      end
-
-      context '#module_class' do
-        it 'is module_instance.module_class' do
-          expect(class_template.module_class).to eq(module_instance.module_class)
-        end
-      end
-    end
-
-    context 'without #module_instance' do
-      let(:module_instance) do
-        nil
-      end
-
-      it { should be_nil }
-    end
-  end
-
-  context 'write' do
-    subject(:write) do
-      described_class.write(attributes)
-    end
-
-    context 'with valid' do
-      let(:attributes) do
-        {
-            module_instance: module_instance
-        }
-      end
-
-      it { should be_true }
-
-      it 'writes template' do
-        # memoize attributes so any other writes besides the one under-test are already run.
-        attributes
-
-        described_class.any_instance.should_receive(:write)
-
-        write
-      end
-    end
-
-    context 'without valid' do
-      let(:attributes) do
-        {}
-      end
-
-      it { should be_false }
-
-      it 'does not write template' do
-        described_class.any_instance.should_not_receive(:write)
-
-        write
-      end
-    end
-  end
-
-  context '#write' do
-    subject(:write) do
-      template.write
-    end
-
-    it 'delegates to #class_template' do
-      expected = double('#write')
-
-      expect(template.class_template).to receive(:write).and_return(expected)
-      expect(write).to eq(expected)
-    end
-  end
-end

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

@@ -1,62 +0,0 @@
-require 'spec_helper'
-
-describe Metasploit::Model::Search::Operator::Deprecated::App do
-  subject(:operator) do
-    described_class.new(
-        :klass => klass
-    )
-  end
-
-  let(:klass) do
-    Class.new
-  end
-
-  it { should be_a Metasploit::Model::Search::Operator::Delegation }
-
-  context 'CONSTANTS' do
-    context 'STANCE_BY_APP' do
-      subject(:stance_by_app) do
-        described_class::STANCE_BY_APP
-      end
-
-      its(['client']) { should == 'passive' }
-      its(['server']) { should == 'aggressive' }
-    end
-  end
-
-  context '#operate_on' do
-    subject(:operation) do
-      operator.operate_on(formatted_value)
-    end
-
-    let(:stance_operator) do
-      Metasploit::Model::Search::Operator::Attribute.new(
-          :attribute => :stance,
-          :klass => klass,
-          :type => :string
-      )
-    end
-
-    before(:each) do
-      operator.stub(:operator).with('stance').and_return(stance_operator)
-    end
-
-    context 'with client' do
-      let(:formatted_value) do
-        'client'
-      end
-
-      its('operator.name') { should == :stance }
-      its(:value) { should == 'passive' }
-    end
-
-    context 'with server' do
-      let(:formatted_value) do
-        'server'
-      end
-
-      its('operator.name') { should == :stance }
-      its(:value) { should == 'aggressive' }
-    end
-  end
-end