metasploit-model 0.24.1-java

data/spec/lib/metasploit/model/configuration/child_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe Metasploit::Model::Configuration::Child do
+  subject(:child) do
+    described_class.new
+  end
+
+  context '#configuration' do
+    subject(:configuration) do
+      child.configuration
+    end
+
+    context 'default' do
+      it { should be_nil }
+    end
+
+    it 'should be settable' do
+      expected_configuration = double('Configuration')
+      child.configuration = expected_configuration
+
+      expect(child.configuration).to eq expected_configuration
+    end
+  end
+end

data/spec/lib/metasploit/model/configuration/error_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe Metasploit::Model::Configuration::Error do
+  it { should be_a Metasploit::Model::Error }
+end

data/spec/lib/metasploit/model/configuration/i18n_spec.rb

@@ -0,0 +1,103 @@
+require 'spec_helper'
+
+describe Metasploit::Model::Configuration::I18n do
+  include_context 'Metasploit::Model::Configuration'
+
+  let(:i18n) do
+    described_class.new.tap { |i18n|
+      i18n.configuration = configuration
+    }
+  end
+
+  context '#directories' do
+    subject(:directories) do
+      i18n.directories
+    end
+
+    it 'should use configuration.root to convert #relative_directories to absolute paths' do
+      relative_directories = [
+          'foo/bar'
+      ]
+
+      i18n.stub(relative_directories: relative_directories)
+
+      directories.should == [Metasploit::Model.root.join('spec', 'dummy', 'foo', 'bar').to_path]
+    end
+  end
+
+  context '#paths' do
+    subject(:paths) do
+      i18n.paths
+    end
+
+    it 'should be a flat Array' do
+      nested_array = ['a', 'b']
+      Dir.stub(:glob).and_return(nested_array)
+      i18n.stub(directories: ['d1', 'd2'])
+
+      expect(paths).to match_array(nested_array + nested_array)
+    end
+
+    it 'should look for yml files' do
+      Dir.should_receive(:glob) do |glob|
+        glob.should end_with('*.yml')
+      end
+
+      paths
+    end
+  end
+
+  context '#relative_directories' do
+    subject(:relative_directories) do
+      i18n.relative_directories
+    end
+
+    it { should include('config/locales') }
+  end
+
+  context '#setup' do
+    subject(:setup) do
+      i18n.setup
+    end
+
+    let(:path) do
+      Metasploit::Model.root.join('spec', 'dummy', 'config', 'locales', 'en.yml').to_path
+    end
+
+    let(:paths) do
+      [
+          path
+      ]
+    end
+
+    before(:each) do
+      @before_i18n_load_path = ::I18n.load_path
+
+      i18n.stub(paths: paths)
+    end
+
+    after(:each) do
+      ::I18n.load_path = @before_i18n_load_path
+    end
+
+    context 'with in I18n.load_path already' do
+      before(:each) do
+        ::I18n.load_path << path
+      end
+
+      it 'should not add path to I18n.load_path' do
+        expect {
+          setup
+        }.to_not change(::I18n, :load_path)
+      end
+    end
+
+    context 'without in I18n.load_path already' do
+      it 'should add path to I18n.load_path' do
+        setup
+
+        ::I18n.load_path.should include(path)
+      end
+    end
+  end
+end

data/spec/lib/metasploit/model/configuration_spec.rb

@@ -0,0 +1,106 @@
+require 'spec_helper'
+
+describe Metasploit::Model::Configuration do
+  include_context 'Metasploit::Model::Configuration'
+
+  subject do
+    configuration
+  end
+
+  it_should_behave_like 'Metasploit::Model::Configuration::Parent#child',
+                        :autoload,
+                        class: Metasploit::Model::Configuration::Autoload
+
+  it_should_behave_like 'Metasploit::Model::Configuration::Parent#child',
+                        :i18n,
+                        class: Metasploit::Model::Configuration::I18n
+
+  context '#root' do
+    subject(:root) do
+      configuration.root
+    end
+
+    let(:configuration) do
+      described_class.new
+    end
+
+    context 'with setting first' do
+      #
+      # lets
+      #
+
+      let(:expected_root_pathname) do
+        Metasploit::Model.root.join('spec', 'dummy')
+      end
+
+      #
+      # Callbacks
+      #
+
+      before(:each) do
+        configuration.root = expected_root
+      end
+
+      context 'with Pathname' do
+        let(:expected_root) do
+          expected_root_pathname
+        end
+
+        it { should be_a Pathname }
+
+        it 'should return set Pathname' do
+          root.should == expected_root
+        end
+      end
+
+      context 'with String' do
+        let(:expected_root) do
+          expected_root_pathname.to_s
+        end
+
+        it { should be_a Pathname }
+
+        it 'should return String as Pathname' do
+          root.should == expected_root_pathname
+        end
+      end
+    end
+
+    context 'without setting first' do
+      specify {
+        expect {
+          root
+        }.to raise_error Metasploit::Model::Configuration::Error
+      }
+    end
+  end
+
+  context '#setup' do
+    subject(:setup) do
+      configuration.setup
+    end
+
+    before(:each) do
+      @before_autoload_paths = ActiveSupport::Dependencies.autoload_paths.dup
+      ActiveSupport::Dependencies.autoload_paths.clear
+
+      @before_autoload_once_paths = ActiveSupport::Dependencies.autoload_once_paths.dup
+      ActiveSupport::Dependencies.autoload_once_paths.clear
+
+      @before_i18n_load_path = ::I18n.load_path
+    end
+
+    after(:each) do
+      ActiveSupport::Dependencies.autoload_paths = @before_autoload_paths
+      ActiveSupport::Dependencies.autoload_once_paths = @before_autoload_once_paths
+
+      ::I18n.load_path = @before_i18n_load_path
+    end
+
+    it 'should setup autoload' do
+      configuration.autoload.should_receive(:setup)
+
+      setup
+    end
+  end
+end

data/spec/lib/metasploit/model/configured_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe Metasploit::Model::Configured do
+  subject(:configured) do
+    Module.new.tap { |m|
+      m.extend described_class
+    }
+  end
+
+  context 'configuration' do
+    subject(:configuration) do
+      configured.configuration
+    end
+
+    it { should be_a Metasploit::Model::Configuration }
+  end
+
+  context 'root' do
+    subject(:root) do
+      configured.root
+    end
+
+    it 'should delegate to configuration' do
+      configured.configuration.should_receive(:root)
+
+      root
+    end
+  end
+
+  context 'setup' do
+    subject(:setup) do
+      configured.setup
+    end
+
+    it 'should delegate to configuration' do
+      configured.configuration.should_receive(:setup)
+
+      setup
+    end
+  end
+end

data/spec/lib/metasploit/model/derivation/full_name_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+describe Metasploit::Model::Derivation::FullName do
+  subject(:base_instance) do
+    base_class.new
+  end
+
+  let(:base_class) do
+    # capture for Class.new scope
+    described_class = self.described_class
+
+    Class.new do
+      include described_class
+
+      #
+      # Attributes
+      #
+
+      # @!attribute [rw] module_type
+      #   The type of module.
+      #
+      #   @return [String]
+      attr_accessor :module_type
+
+      # @!attribute [rw] reference_name
+      #   The name of the module scoped to the {#module_type}
+      #
+      #   @return [String]
+      attr_accessor :reference_name
+    end
+  end
+
+  context '#derived_full_name' do
+    subject(:derived_full_name) do
+      base_instance.derived_full_name
+    end
+
+    let(:module_type) do
+      nil
+    end
+
+    let(:reference_name) do
+      nil
+    end
+
+    before(:each) do
+      base_instance.module_type = module_type
+      base_instance.reference_name = reference_name
+    end
+
+    context 'with module_type' do
+      let(:module_type) do
+        FactoryGirl.generate :metasploit_model_module_type
+      end
+
+      context 'with reference_name' do
+        let(:reference_name) do
+          FactoryGirl.generate :metasploit_model_module_ancestor_reference_name
+        end
+
+        it 'should be <module_type>/<reference_name>' do
+          derived_full_name.should == "#{module_type}/#{reference_name}"
+        end
+      end
+
+      context 'without reference_name' do
+        it { should be_nil }
+      end
+    end
+
+    context 'without module_type' do
+      it { should be_nil }
+    end
+  end
+end

data/spec/lib/metasploit/model/derivation_spec.rb

@@ -0,0 +1,217 @@
+require 'spec_helper'
+
+describe Metasploit::Model::Derivation do
+  let(:base_class) do
+    # capture for class_eval scope
+    described_class = self.described_class
+
+    Class.new do
+      extend ActiveModel::Callbacks
+      include ActiveModel::Validations
+      include ActiveModel::Validations::Callbacks
+
+      include described_class
+    end
+  end
+
+  context 'included' do
+    let(:base_class) do
+      Class.new do
+        extend ActiveModel::Callbacks
+        include ActiveModel::Validations
+        include ActiveModel::Validations::Callbacks
+      end
+    end
+
+    it 'should register #derive as a before validation callback' do
+      base_class.should_receive(:before_validation).with(:derive)
+
+      # capture for class_eval scope
+      described_class = self.described_class
+
+      base_class.class_eval do
+        include described_class
+      end
+    end
+  end
+
+  context '#derive' do
+    subject(:derive) do
+      base_instance.send(:derive)
+    end
+
+    let(:attributes) do
+      [
+          :derivation,
+          :formula
+      ]
+    end
+
+    let(:base_instance) do
+      base_class.new
+    end
+
+    let(:derivation) do
+      'derivation'
+    end
+
+    let(:formula) do
+      nil
+    end
+
+    before(:each) do
+      # capture for class_eval scope
+      attributes = self.attributes
+
+      base_class.class_eval do
+        #
+        # Attributes
+        #
+
+        # @!attribute [rw] derivation
+        #   @return [String]
+        attr_accessor :derivation
+
+        # @!attribute [rw] formula
+        #   @return [String]
+        attr_accessor :formula
+
+        #
+        # Derivations
+        #
+
+        derives :derivation
+        derives :formula
+
+        #
+        # Methods
+        #
+
+        # Derives #derivation.
+        #
+        # @return [String]
+        def derived_derivation
+          'derived_derivation'
+        end
+
+        # Derives #formula.
+        #
+        # @return [String]
+        def derived_formula
+          'derived_formula'
+        end
+      end
+
+      base_instance.derivation = derivation
+      base_instance.formula = formula
+    end
+
+    it 'should test value with nil?' do
+      derivation.should_receive(:nil?).and_return(false)
+
+      derive
+    end
+
+    context 'with nil value' do
+      it 'should set attribute to derived_<attribute>' do
+        derive
+
+        base_instance.formula.should == base_instance.derived_formula
+      end
+    end
+
+    context 'without nil value' do
+      it 'should not set attribute to derived_<attribute>' do
+        derive
+
+        base_instance.derivation.should_not == base_instance.derived_derivation
+      end
+    end
+  end
+
+  context 'derives' do
+    let(:attribute) do
+      :derivative
+    end
+
+    context 'with :validate' do
+      subject(:derives) do
+        base_class.derives attribute, :validate => validate
+      end
+
+      context 'false' do
+        let(:validate) do
+          false
+        end
+
+        it 'should record :validate in validate_by_derived_attribute' do
+          derives
+
+          base_class.validate_by_derived_attribute[attribute].should == validate
+        end
+
+        it 'should not add derivation validation on attribute' do
+          base_class.should_not_receive(:validates).with(
+              attribute,
+              hash_including(
+                  :derivation => true
+              )
+          )
+
+          derives
+        end
+      end
+
+      context 'true' do
+        let(:validate) do
+          true
+        end
+
+        it 'should record :validate in validate_by_derived_attribute' do
+          derives
+
+          base_class.validate_by_derived_attribute[attribute].should == validate
+        end
+
+        it 'should not add derivation validation on attribute' do
+          base_class.should_receive(:validates).with(
+              attribute,
+              hash_including(
+                  :derivation => true
+              )
+          )
+
+          derives
+        end
+      end
+    end
+
+    context 'without :validate' do
+      subject(:derives) do
+        base_class.derives attribute
+      end
+
+      it 'should default to false' do
+        derives
+
+        base_class.validate_by_derived_attribute[attribute].should be_false
+      end
+
+      it 'should not call validates' do
+        base_class.should_not_receive(:validates)
+
+        derives
+      end
+    end
+  end
+
+  context 'validate_by_derived_attribute' do
+    subject(:validate_by_derived_attribute) do
+      base_class.validate_by_derived_attribute
+    end
+
+    it 'should default to {}' do
+      validate_by_derived_attribute.should == {}
+    end
+  end
+end