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

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

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

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

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe Metasploit::Model::Spec::I18nExceptionHandler do
+  subject(:i18n_exception_handler) do
+    described_class.new
+  end
+
+  context '#call' do
+    subject(:call) do
+      i18n_exception_handler.call(exception, locale, key, options)
+    end
+
+    let(:exception) do
+      I18n::MissingTranslation.new(locale, key, options)
+    end
+
+    let(:locale) do
+      :en
+    end
+
+    let(:key) do
+      :'missing.key'
+    end
+
+    let(:options) do
+      {}
+    end
+
+    it 'should raise exception.to_exception' do
+      converted_exception = exception.to_exception
+
+      expect {
+        call
+      }.to raise_error(converted_exception.class) do |actual_exception|
+        actual_exception.class == converted_exception.class
+        actual_exception.key.should == converted_exception.key
+        actual_exception.locale.should == converted_exception.locale
+        actual_exception.options.should == converted_exception.options
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe Metasploit::Model::Spec::PathnameCollision do
+  let(:pathname) do
+    Metasploit::Model::Spec.temporary_pathname.join('pathname')
+  end
+
+  subject(:pathname_collision) do
+    described_class.new(pathname)
+  end
+
+  it { should be_a Metasploit::Model::Spec::Error }
+
+  context 'check!' do
+    subject(:check!) do
+      described_class.check!(pathname)
+    end
+
+    context 'with existing Pathname' do
+      before(:each) do
+        pathname.mkpath
+      end
+
+      it 'should raise Metasploit::Model::Spec::PathnameCollision' do
+        expect {
+          check!
+        }.to raise_error(described_class)
+      end
+    end
+
+    context 'without existing Pathname' do
+      it 'should not raise error' do
+        expect {
+          check!
+        }.to_not raise_error
+      end
+    end
+  end
+
+  context '#initialize' do
+    context '#message' do
+      subject(:message) do
+        pathname_collision.message
+      end
+
+      it 'should include pathname' do
+        message.should include("#{pathname} already exists.")
+      end
+
+      it 'should include potential cause' do
+        message.should include('Metasploit::Model::Spec.remove_temporary_pathname was not called after the previous spec.')
+      end
+    end
+  end
+end

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

@@ -0,0 +1,114 @@
+require 'spec_helper'
+
+describe Metasploit::Model::Spec do
+  before(:each) do
+    @before_temporary_pathname = described_class.send(:remove_instance_variable, :@temporary_pathname)
+  end
+
+  after(:each) do
+    described_class.instance_variable_set(:@temporary_pathname, @before_temporary_pathname)
+  end
+
+  context 'remove_temporary_pathname' do
+    subject(:remove_temporary_pathname) do
+      described_class.remove_temporary_pathname
+    end
+
+    let(:pathname) do
+      Metasploit::Model.root.join('spec', 'pathname')
+    end
+
+    context 'with temporary_pathname set' do
+      before(:each) do
+        described_class.temporary_pathname = pathname
+      end
+
+      context 'that exists' do
+        before(:each) do
+          pathname.mkpath
+
+          child_pathname = pathname.join('child')
+
+          child_pathname.open('wb') do |f|
+            f.puts 'Child File'
+          end
+        end
+
+        it 'should remove file tree' do
+          pathname.exist?.should be_true
+
+          remove_temporary_pathname
+
+          pathname.exist?.should be_false
+        end
+      end
+
+      context 'that does not exist' do
+        it 'should not raise an error' do
+          expect {
+            remove_temporary_pathname
+          }.to_not raise_error
+        end
+      end
+    end
+
+    context 'without temporary_pathname set' do
+      it 'should not error' do
+        expect {
+          remove_temporary_pathname
+        }.to_not raise_error
+      end
+    end
+  end
+
+  context 'temporary_pathname' do
+    subject(:temporary_pathname) do
+      described_class.temporary_pathname
+    end
+
+    context 'with @temporary_pathname defined' do
+      let(:pathname) do
+        Metasploit::Model.root.join('spec', 'pathname')
+      end
+
+      before(:each) do
+        described_class.temporary_pathname = pathname
+      end
+
+      it 'should not raise error' do
+        expect {
+          temporary_pathname
+        }.to_not raise_error
+      end
+
+      it 'should return set pathname' do
+        temporary_pathname.should == pathname
+      end
+    end
+
+    context 'without @temporary_pathname defined' do
+      it 'should raise Metasploit::Model::Spec::Error' do
+        expect {
+          temporary_pathname
+        }.to raise_error(
+                 Metasploit::Model::Spec::Error,
+                 'Metasploit::Model::Spec.temporary_pathname not set prior to use'
+             )
+      end
+    end
+  end
+
+  context 'temporary_pathname=' do
+    let(:temporary_pathname) do
+      Metasploit::Model.root.join('spec', 'temporary_pathname')
+    end
+
+    it 'should set @temporary_pathname' do
+      expect {
+        described_class.temporary_pathname = temporary_pathname
+      }.to change {
+        described_class.instance_variable_get(:@temporary_pathname)
+      }.to(temporary_pathname)
+    end
+  end
+end

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

@@ -0,0 +1,82 @@
+require 'spec_helper'
+
+describe Metasploit::Model::Translation do
+  let(:base_class) do
+    described_class = self.described_class
+
+    Class.new do
+      include described_class
+    end
+  end
+
+  context 'lookup_ancestors' do
+    subject(:lookup_ancestors) do
+      base_class.lookup_ancestors
+    end
+
+    let(:base_class) do
+      described_class = self.described_class
+
+      Class.new(named_class) do
+        include described_class
+      end
+    end
+
+    let(:named_class) do
+      named_module = self.named_module
+      unnamed_class = self.unnamed_class
+
+      Class.new(unnamed_class) do
+        include named_module
+
+        def self.model_name
+
+        end
+      end
+    end
+
+    let(:named_module) do
+      Module.new do
+        def self.model_name
+
+        end
+      end
+    end
+
+    let(:unnamed_class) do
+      unnamed_module = self.unnamed_module
+
+      Class.new do
+        include unnamed_module
+      end
+    end
+
+    let(:unnamed_module) do
+      Module.new
+    end
+
+    it 'should have named and unnamed ancestors' do
+      base_class.ancestors.should include(named_class)
+      base_class.ancestors.should include(named_module)
+      base_class.ancestors.should include(unnamed_class)
+      base_class.ancestors.should include(unnamed_module)
+    end
+
+    it 'should return all ancestors that respond to model_name' do
+      lookup_ancestors.should include(base_class)
+      lookup_ancestors.should include(named_class)
+      lookup_ancestors.should include(named_module)
+    end
+
+    it 'should not return ancestors that do not respond to model_name' do
+      lookup_ancestors.should_not include(unnamed_class)
+      lookup_ancestors.should_not include(unnamed_module)
+    end
+  end
+
+  context 'i18n_scope' do
+    subject(:i18n_scope) do
+      'metasploit.model'
+    end
+  end
+end

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

@@ -0,0 +1,141 @@
+require 'spec_helper'
+
+describe Metasploit::Model::Version do
+  context 'CONSTANTS' do
+    context 'MAJOR' do
+      subject(:major) do
+        described_class::MAJOR
+      end
+
+      it 'is 0 because the API is not locked yet' do
+        expect(major).to eq(0)
+      end
+    end
+
+    context 'MINOR' do
+      subject(:minor) do
+        described_class::MINOR
+      end
+
+      it { should be_a Integer }
+    end
+
+    context 'PATCH' do
+      subject(:patch) do
+        described_class::PATCH
+      end
+
+      it { should be_a Integer }
+    end
+
+    pull_request = ENV['TRAVIS_PULL_REQUEST']
+
+    # a pull request cannot check PRERELEASE because it will be tested in the target branch, but the source itself
+    # is from the source branch and so has the source branch PRERELEASE.
+    #
+    # PRERELEASE can only be set appropriately for a merge by merging to the target branch and then updating PRERELEASE
+    # on the target branch before committing and/or pushing to github and travis-ci.
+    if pull_request.nil? || pull_request == 'false'
+      context 'PREPRELEASE' do
+        subject(:prerelease) do
+          described_class::PRERELEASE
+        end
+
+        branch = ENV['TRAVIS_BRANCH']
+
+        if branch.blank?
+          branch = `git rev-parse --abbrev-ref HEAD`.strip
+        end
+
+        if branch == 'master'
+          it 'does not have a PRERELEASE' do
+            expect(defined? described_class::PRERELEASE).to be_nil
+          end
+        else
+          branch_regex = /\A(?<type>bug|chore|feature|staging)(\/(?<story>[^\/]+))?\/(?<prerelease>[^\/]+)\z/
+          match = branch.match(branch_regex)
+
+          if match
+            it 'matches the branch relative name' do
+              expect(prerelease).to eq(match[:prerelease])
+            end
+          else
+            tag_regex = /\Av(?<major>\d+).(?<minor>\d+).(?<patch>\d+)(-(?<prerelease>.*))?\z/
+            # travis-ci sets TRAVIS_BRANCH to the tag name for tag builds
+            match = branch.match(tag_regex)
+
+            if match
+              tag_prerelease = match[:prerelease]
+
+              if tag_prerelease
+                it 'matches the tag prerelease' do
+                  expect(prerelease).to eq(tag_prerelease)
+                end
+              else
+                it 'does not have a PRERELEASE' do
+                  expect(defined? described_class::PRERELEASE).to be_nil
+                end
+              end
+            else
+              it 'has a abbreviated reference that can be parsed for prerelease' do
+                fail "Do not know how to parse #{branch.inspect} for PRERELEASE"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+
+  context 'full' do
+    subject(:full) do
+      described_class.full
+    end
+
+    #
+    # lets
+    #
+
+    let(:major) do
+      1
+    end
+
+    let(:minor) do
+      2
+    end
+
+    let(:patch) do
+      3
+    end
+
+    before(:each) do
+      stub_const("#{described_class}::MAJOR", major)
+      stub_const("#{described_class}::MINOR", minor)
+      stub_const("#{described_class}::PATCH", patch)
+    end
+
+    context 'with PRERELEASE' do
+      let(:prerelease) do
+        'prerelease'
+      end
+
+      before(:each) do
+        stub_const("#{described_class}::PRERELEASE", prerelease)
+      end
+
+      it 'is <major>.<minor>.<patch>-<prerelease>' do
+        expect(full).to eq("#{major}.#{minor}.#{patch}-#{prerelease}")
+      end
+    end
+
+    context 'without PRERELEASE' do
+      before(:each) do
+        hide_const("#{described_class}::PRERELEASE")
+      end
+
+      it 'is <major>.<minor>.<patch>' do
+        expect(full).to eq("#{major}.#{minor}.#{patch}")
+      end
+    end
+  end
+end

data/spec/lib/metasploit/model/visitation/visit_spec.rb

@@ -0,0 +1,316 @@
+require 'spec_helper'
+
+describe Metasploit::Model::Visitation::Visit do
+  let(:base_class) do
+    described_class = self.described_class
+
+    Class.new do
+      include described_class
+    end
+  end
+
+  context 'visit' do
+    subject(:visit) do
+      base_class.visit(*module_names, &block)
+    end
+
+    context 'with 0 Module#names' do
+      let(:block) do
+        nil
+      end
+
+      let(:module_names) do
+        []
+      end
+
+      it 'should raise ArgumentError' do
+        expect {
+          visit
+        }.to raise_error(ArgumentError)
+      end
+    end
+
+    context 'with block' do
+      let(:block) do
+        lambda { |node|
+          node
+        }
+      end
+
+      context 'with 1 Module#name' do
+        let(:module_names) do
+          [
+              mod.name
+          ]
+        end
+
+        let(:mod) do
+          Module.new
+        end
+
+        before(:each) do
+          # give mod a Module#name for use in options
+          stub_const('Visited', mod)
+        end
+
+        it 'should return Array(Metasploit::Model::Visitation::Visitor)' do
+          visit.should be_an Array
+          visit.length.should == 1
+          visit.first.should be_a Metasploit::Model::Visitation::Visitor
+        end
+
+        it 'should add Metasploit::Model::Visitation::Visitor to visitor_by_module_name' do
+          visitor = visit.first
+
+          base_class.visitor_by_module_name[mod.name].should == visitor
+        end
+      end
+
+      context 'with multiple Module#names' do
+        let(:first_module) do
+          Module.new
+        end
+
+        let(:module_names) do
+          [
+              first_module.name,
+              second_module.name
+          ]
+        end
+
+        let(:second_module) do
+          Module.new
+        end
+
+        before(:each) do
+          stub_const('Visited::First', first_module)
+          stub_const('Visited::Second', second_module)
+        end
+
+        it 'should return Array<Metasploit::Model::Visitation::Visitor>' do
+          visit.should be_an Array
+          visit.length.should == module_names.length
+
+          visit.all? { |visitor|
+            visitor.is_a? Metasploit::Model::Visitation::Visitor
+          }.should be_true
+        end
+
+        it 'should each Metasploit::Model::Visitation::Visitor to visitor_by_module_name' do
+          module_names.all? { |module_name|
+            visit.include? base_class.visitor_by_module_name[module_name]
+          }.should be_true
+        end
+      end
+    end
+
+    context 'without block' do
+      let(:block) do
+        nil
+      end
+
+      let(:module_names) do
+        ['Visited']
+      end
+
+      it 'should raise Metasploit::Model::Invalid' do
+        expect {
+          visit
+        }.to raise_error(Metasploit::Model::Invalid)
+      end
+    end
+  end
+
+  context 'visitor' do
+    subject(:visitor) do
+      base_class.visitor(klass)
+    end
+
+    let(:block) do
+      lambda { |node|
+        node
+      }
+    end
+
+    let(:klass) do
+      Class.new
+    end
+
+    let(:klass_visitor) do
+      Metasploit::Model::Visitation::Visitor.new(
+          :module_name => klass.name,
+          :parent => parent,
+          &block
+      )
+    end
+
+    let(:parent) do
+      Class.new
+    end
+
+    before(:each) do
+      stub_const('Visited::Class', klass)
+    end
+
+    context 'with klass in visitor_by_module' do
+      before(:each) do
+        base_class.visitor_by_module[klass] = klass_visitor
+      end
+
+      it 'should return visitor from visitor_by_module' do
+        visitor.should == klass_visitor
+      end
+    end
+
+    context 'without klass in visitor_by_module' do
+      let(:ancestor) do
+        Module.new
+      end
+
+      let(:ancestor_visitor) do
+        Metasploit::Model::Visitation::Visitor.new(
+            :module_name => ancestor.name,
+            :parent => parent,
+            &block
+        )
+      end
+
+      before(:each) do
+        stub_const('Visited::Ancestor', ancestor)
+
+        klass.send(:include, ancestor)
+      end
+
+      context 'with ancestor in visitor_by_module' do
+        before(:each) do
+          base_class.visitor_by_module[ancestor] = ancestor_visitor
+        end
+
+        it 'should return ancestor visitor' do
+          visitor.should == ancestor_visitor
+        end
+
+        it 'should cache ancestor visitor as visitor for klass in visitor_by_module' do
+          visitor
+
+          base_class.visitor_by_module[klass].should == ancestor_visitor
+        end
+      end
+
+      context "with ancestor Module#name in visitor_by_module_name" do
+        before(:each) do
+          base_class.visitor_by_module_name[ancestor.name] = ancestor_visitor
+        end
+
+        it 'should return ancestor visitor' do
+          visitor.should == ancestor_visitor
+        end
+
+        it 'should cache ancestor visitor as visitor for klass in visitor_by_module' do
+          visitor
+
+          base_class.visitor_by_module[klass].should == ancestor_visitor
+        end
+      end
+
+      context 'without visitor for ancestor' do
+        it 'should raise TypeError' do
+          expect {
+            visitor
+          }.to raise_error(TypeError)
+        end
+      end
+    end
+  end
+
+  context 'visitor_by_module' do
+    subject(:visitor_by_module) do
+      base_class.visitor_by_module
+    end
+
+    it 'should default to empty Hash' do
+      visitor_by_module.should == {}
+    end
+  end
+
+  context 'visitor_by_module_name' do
+    subject(:visitor_by_module_name) do
+      base_class.visitor_by_module_name
+    end
+
+    it 'should default to empty Hash' do
+      visitor_by_module_name.should == {}
+    end
+  end
+
+  context '#visit' do
+    subject(:visit) do
+      base_instance.visit(node)
+    end
+
+    let(:base_instance) do
+      base_class.new
+    end
+
+    let(:block) do
+      lambda { |node|
+        node
+      }
+    end
+
+    let(:node) do
+      node_class.new
+    end
+
+    let(:node_class) do
+      Class.new
+    end
+
+    before(:each) do
+      stub_const('Visited::Class', node_class)
+
+      visitors = base_class.visit node.class.name, &block
+      @visitor = visitors.first
+    end
+
+    it 'should find visitor for node.class' do
+      base_class.should_receive(:visitor).with(node.class).and_call_original
+
+      visit
+    end
+
+    it 'should visit on visitor' do
+      @visitor.should_receive(:visit).with(base_instance, node)
+
+      visit
+    end
+
+    context 'recursion' do
+      let(:block) do
+        lambda { |node|
+          if node.child
+            visit node.child
+          else
+            node
+          end
+        }
+      end
+
+      let(:leaf_node) do
+        node_class.new
+      end
+
+      before(:each) do
+        node_class.class_eval do
+          attr_accessor :child
+        end
+
+        node.child = leaf_node
+      end
+
+      it "should be able to call visit from inside a visitor's block" do
+        visit.should == leaf_node
+      end
+    end
+  end
+end