metasploit-model 0.24.1-java

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