metasploit-model 0.24.1.pre.semantic.pre.versioning.pre.2.pre.0

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

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

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe Metasploit::Model::EmailAddress,
+         # setting the metadata type makes rspec-rails include RSpec::Rails::ModelExampleGroup, which includes a better
+         # be_valid matcher that will print full error messages
+         type: :model  do
+  it_should_behave_like 'Metasploit::Model::EmailAddress',
+                        namespace_name: 'Dummy' do
+     def attribute_type(attribute)
+      type_by_attribute = {
+        domain: :string,
+        full: :string,
+        local: :string
+      }
+
+      type_by_attribute.fetch(attribute)
+    end
+  end
+end

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

@@ -0,0 +1,84 @@
+require 'spec_helper'
+
+describe Metasploit::Model::Engine do
+  context 'config' do
+    subject(:config) do
+      described_class.config
+    end
+
+    context 'generators' do
+      subject(:generators) do
+        config.generators
+      end
+
+      context 'options' do
+        subject(:options) do
+          generators.options
+        end
+
+        context 'factory_girl' do
+          subject(:factory_girl) do
+            options[:factory_girl]
+          end
+
+          its([:dir]) { should == 'spec/factories' }
+        end
+
+        context 'rails' do
+          subject(:rails) do
+            options[:rails]
+          end
+
+          its([:assets]) { should be_false }
+          its([:fixture_replacement]) { should == :factory_girl }
+          its([:helper]) { should be_false }
+          its([:test_framework]) { should == :rspec }
+        end
+
+        context 'rspec' do
+          subject(:rspec) do
+            options[:rspec]
+          end
+
+          its([:fixture]) { should be_false }
+        end
+      end
+    end
+  end
+
+  context 'initializers' do
+    subject(:initializers) do
+      # need to use Rails's initialized copy of Dummy::Application so that initializers have the correct context when
+      # run
+      Rails.application.initializers
+    end
+
+    context 'metasploit-model.prepend_factory_path' do
+      subject(:initializer) do
+        initializers.find { |initializer|
+          initializer.name == 'metasploit-model.prepend_factory_path'
+        }
+      end
+
+      it 'should run after factory_girl.set_factory_paths' do
+        initializer.after.should == 'factory_girl.set_factory_paths'
+      end
+
+      context 'running' do
+        def run
+          initializer.run
+        end
+
+        context 'with FactoryGirl defined' do
+          it 'should prepend full path to spec/factories to FactoryGirl.definition_file_paths' do
+            definition_file_path = Metasploit::Model.root.join('spec', 'factories')
+
+            FactoryGirl.definition_file_paths.should_receive(:unshift).with(definition_file_path)
+
+            run
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe Metasploit::Model::File do
+  context 'realpath' do
+    let(:real_basename) do
+      'real'
+    end
+
+    let(:real_pathname) do
+      Metasploit::Model::Spec.temporary_pathname.join(real_basename)
+    end
+
+    let(:symlink_basename) do
+      'symlink'
+    end
+
+    let(:symlink_pathname) do
+      Metasploit::Model::Spec.temporary_pathname.join(symlink_basename)
+    end
+
+    before(:each) do
+      real_pathname.mkpath
+
+      Dir.chdir(Metasploit::Model::Spec.temporary_pathname.to_path) do
+        File.symlink(real_basename, 'symlink')
+      end
+    end
+
+    def realpath
+      described_class.realpath(symlink_pathname.to_path)
+    end
+
+    if RUBY_PLATFORM =~ /java/
+      it 'should be necessary because File.realpath does not resolve symlinks' do
+        File.realpath(symlink_pathname.to_path).should_not == real_pathname.to_path
+      end
+    end
+
+    it 'should resolve symlink to real (canonical) path' do
+      realpath.should == real_pathname.to_path
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe Metasploit::Model::Invalid do
+  subject(:invalid) do
+    described_class.new(model)
+  end
+
+  let(:model) do
+    model_class.new
+  end
+
+  let(:model_class) do
+    Class.new do
+      include ActiveModel::Validations
+    end
+  end
+
+  it { should be_a Metasploit::Model::Error }
+
+  it 'should use ActiveModel::Errors#full_messages' do
+    model.errors.should_receive(:full_messages).and_call_original
+
+    described_class.new(model)
+  end
+
+  it 'should translate errors using metasploit.model.invalid' do
+    I18n.should_receive(:translate).with(
+        'metasploit.model.errors.messages.model_invalid',
+        hash_including(
+            :errors => anything
+        )
+    ).and_call_original
+
+    described_class.new(model)
+  end
+
+  it 'should set translated errors as message' do
+    message = "translated message"
+    I18n.stub(:translate).with('metasploit.model.errors.messages.model_invalid', anything).and_return(message)
+    instance = described_class.new(model)
+
+    instance.message.should == message
+  end
+
+  context '#model' do
+    subject(:error_model) do
+      invalid.model
+    end
+
+    it 'should be the passed in model' do
+      error_model.should == model
+    end
+  end
+end