metasploit-model 0.24.1-java

data/spec/support/shared/examples/metasploit/model/module/ancestor/payload_factory.rb

@@ -0,0 +1,63 @@
+shared_examples_for 'Metasploit::Model::Module::Ancestor payload factory' do |options={}|
+  options.assert_valid_keys(:handler_type)
+
+  should_have_handler_type = options[:handler_type]
+
+  its(:module_type) { should == 'payload' }
+
+  context 'contents' do
+    include_context 'Metasploit::Model::Module::Ancestor factory contents'
+
+    context 'metasploit_module' do
+      include_context 'Metasploit::Model::Module::Ancestor factory contents metasploit_module'
+
+      it { should be_a Module }
+      it { should_not be_a Class }
+
+      # nil means unknown/indeterminate.  true or false cause specific testing
+      unless should_have_handler_type.nil?
+        if should_have_handler_type
+          method = :should
+        else
+          method = :should_not
+        end
+
+        it { send(method, respond_to(:handler_type_alias)) }
+
+        if should_have_handler_type
+          let(:handler_module) do
+            metasploit_module.handler_module
+          end
+
+          context 'handler_module' do
+            subject do
+              handler_module
+            end
+
+            it_should_behave_like 'Metasploit::Model::Module::Handler'
+
+            context 'handler_type' do
+              subject(:handler_type) do
+                handler_module.handler_type
+              end
+
+              it 'is different than Metasploit::Model::Module::Ancestor#handler_type' do
+                expect(handler_type).not_to eq(module_ancestor.handler_type)
+              end
+            end
+          end
+
+          context 'handler_type_alias' do
+            subject(:handler_type_alias) do
+              metasploit_module.handler_type_alias
+            end
+
+            it 'should be #handler_type' do
+              handler_type_alias.should == module_ancestor.handler_type
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/support/shared/examples/metasploit/model/module/architecture.rb

@@ -0,0 +1,36 @@
+Metasploit::Model::Spec.shared_examples_for 'Module::Architecture' do
+  context 'factories' do
+    context module_architecture_factory.to_s do
+      subject(module_architecture_factory) do
+        FactoryGirl.build(module_architecture_factory)
+      end
+
+      it { should be_valid }
+
+      context '#module_instance' do
+        subject(:module_instance) do
+          send(module_architecture_factory).module_instance
+        end
+
+        it { should be_valid }
+
+        context '#module_architectures' do
+          subject(:module_architectures) do
+            module_instance.module_architectures
+          end
+
+          its(:length) { should == 1 }
+
+          it "should include #{module_architecture_factory}" do
+            expect(module_architectures).to include send(module_architecture_factory)
+          end
+        end
+      end
+    end
+  end
+
+  context 'validations' do
+    it { should validate_presence_of :architecture }
+    it { should validate_presence_of :module_instance }
+  end
+end

data/spec/support/shared/examples/metasploit/model/module/author.rb

@@ -0,0 +1,29 @@
+Metasploit::Model::Spec.shared_examples_for 'Module::Author' do
+  full_module_author_factory = "full_#{module_author_factory}"
+
+  context 'factories' do
+    context module_author_factory do
+      subject(module_author_factory) do
+        FactoryGirl.build(module_author_factory)
+      end
+
+      it { should be_valid }
+    end
+
+    context full_module_author_factory do
+      subject(full_module_author_factory) do
+        FactoryGirl.build(full_module_author_factory)
+      end
+
+      it { should be_valid }
+
+      its(:email_address) { should_not be_nil }
+    end
+  end
+
+  context 'validations' do
+    it { should validate_presence_of(:author) }
+    it { should validate_presence_of(:module_instance) }
+    it { should_not validate_presence_of(:email_address) }
+  end
+end

data/spec/support/shared/examples/metasploit/model/module/class.rb

@@ -0,0 +1,1514 @@
+Metasploit::Model::Spec.shared_examples_for 'Module::Class' do
+  #
+  # Module::Ancestor factories
+  #
+
+  module_ancestor_factory = "#{factory_namespace}_module_ancestor"
+  payload_module_ancestor_factory = "payload_#{module_ancestor_factory}"
+  non_payload_module_ancestor_factory = "non_#{payload_module_ancestor_factory}"
+  single_payload_module_ancestor_factory = "single_#{payload_module_ancestor_factory}"
+  stage_payload_module_ancestor_factory = "stage_#{payload_module_ancestor_factory}"
+  stager_payload_module_ancestor_factory = "stager_#{payload_module_ancestor_factory}"
+
+  #
+  # Module::Class factories
+  #
+
+  module_class_factory = "#{factory_namespace}_module_class"
+
+  context 'CONSTANTS' do
+    context 'PAYLOAD_TYPES' do
+      subject(:payload_types) do
+        described_class::PAYLOAD_TYPES
+      end
+
+      it { should include('single') }
+      it { should include('staged') }
+    end
+
+    context 'STAGED_ANCESTOR_PAYLOAD_TYPES' do
+      subject(:staged_ancestor_payload_types) do
+        described_class::STAGED_ANCESTOR_PAYLOAD_TYPES
+      end
+
+      it { should include('stage') }
+      it { should include('stager') }
+    end
+  end
+
+  context 'derivations' do
+    context 'with module_type derived' do
+      before(:each) do
+        module_class.module_type = module_class.derived_module_type
+      end
+
+      context 'with payload_type derived' do
+        before(:each) do
+          module_class.payload_type = module_class.derived_payload_type
+        end
+
+        context 'with payload module_type' do
+          subject(:module_class) do
+            FactoryGirl.build(
+                module_class_factory,
+                :module_type => 'payload'
+            )
+          end
+
+          it_should_behave_like 'derives', :payload_type, :validates => true
+          it_should_behave_like 'derives', :reference_name, :validates => true
+
+          context 'with payload_type derived' do
+            before(:each) do
+              module_class.payload_type = module_class.derived_payload_type
+            end
+
+            context 'with reference_name derived' do
+              before(:each) do
+                module_class.reference_name = module_class.derived_reference_name
+              end
+
+              it_should_behave_like 'derives', :full_name, :validates => true
+            end
+          end
+        end
+      end
+
+      context 'without payload module_type' do
+        subject(:module_class) do
+          FactoryGirl.build(
+              module_class_factory,
+              :module_type => module_type
+          )
+        end
+
+        let(:module_type) do
+          FactoryGirl.generate :metasploit_model_non_payload_module_type
+        end
+
+        it_should_behave_like 'derives', :reference_name, :validates => true
+
+        context 'with reference_name derived' do
+          before(:each) do
+            module_class.reference_name = module_class.derived_reference_name
+          end
+
+          it_should_behave_like 'derives', :full_name, :validates => true
+        end
+      end
+    end
+
+    it_should_behave_like 'derives', :module_type, :validates => true
+  end
+
+  context 'search' do
+    context 'attributes' do
+      it_should_behave_like 'search_attribute', :full_name, :type => :string
+      it_should_behave_like 'search_attribute', :module_type, :type => :string
+      it_should_behave_like 'search_attribute', :payload_type, :type => :string
+      it_should_behave_like 'search_attribute', :reference_name, :type => :string
+    end
+  end
+
+  context 'factories' do
+    context module_class_factory do
+      subject(module_class_factory) do
+        FactoryGirl.build(module_class_factory)
+      end
+
+      it { should be_valid }
+
+      context '#ancestors' do
+        subject(:ancestors) do
+          send(module_class_factory).ancestors
+        end
+
+        context 'Metasploit::Model::Module::Ancestor#contents list' do
+          subject(:contents_list) do
+            ancestors.map(&:contents)
+          end
+
+          before(:each) do
+            # need to validate so that real_path is derived so contents can be read
+            ancestors.each(&:valid?)
+          end
+
+          context 'metasploit_modules' do
+            include_context 'Metasploit::Model::Module::Ancestor#contents metasploit_module'
+
+            subject(:metasploit_modules) do
+              namespace_modules.collect { |namespace_module|
+                namespace_module_metasploit_module(namespace_module)
+              }
+            end
+
+            let(:namespace_modules) do
+              ancestors.collect {
+                Module.new
+              }
+            end
+
+            before(:each) do
+              namespace_modules.zip(contents_list) do |namespace_module, contents|
+                namespace_module.module_eval(contents)
+              end
+            end
+
+            context 'rank_names' do
+              subject(:rank_names) do
+                metasploit_modules.collect { |metasploit_module|
+                  metasploit_module.rank_name
+                }
+              end
+
+              it 'should match Metasploit::Model::Module::Class#rank Metasploit::Model:Module::Rank#name' do
+                rank_names.all? { |rank_name|
+                  rank_name == send(module_class_factory).rank.name
+                }.should be_true
+              end
+            end
+
+            context 'rank_numbers' do
+              subject(:rank_numbers) do
+                metasploit_modules.collect { |metasploit_module|
+                  metasploit_module.rank_number
+                }
+              end
+
+              it 'should match Metasploit::Model::Module::Class#rank Metasploit::Module::Module::Rank#number' do
+                rank_numbers.all? { |rank_number|
+                  rank_number == send(module_class_factory).rank.number
+                }.should be_true
+              end
+            end
+          end
+        end
+      end
+
+      context 'module_type' do
+        subject(module_class_factory) do
+          FactoryGirl.build(
+              module_class_factory,
+              :module_type => module_type
+          )
+        end
+
+        context 'with payload' do
+          let(:module_type) do
+            'payload'
+          end
+
+          it { should be_valid }
+
+          context 'with payload_type' do
+            subject(module_class_factory) do
+              FactoryGirl.build(
+                  module_class_factory,
+                  :module_type => module_type,
+                  :payload_type => payload_type
+              )
+            end
+
+            context 'single' do
+              let(:payload_type) do
+                'single'
+              end
+
+              it { should be_valid }
+            end
+
+            context 'staged' do
+              let(:payload_type) do
+                'staged'
+              end
+
+              it { should be_valid }
+            end
+
+            context 'other' do
+              let(:payload_type) do
+                'not_a_payload_type'
+              end
+
+              it 'should raise ArgumentError' do
+                expect {
+                  send(module_class_factory)
+                }.to raise_error(ArgumentError)
+              end
+            end
+          end
+        end
+
+        context 'without payload' do
+          let(:module_type) do
+            FactoryGirl.generate :metasploit_model_non_payload_module_type
+          end
+
+          it { should be_valid }
+
+          its(:derived_module_type) { should == module_type }
+        end
+      end
+
+      context 'ancestors' do
+        subject(module_class_factory) do
+          FactoryGirl.build(
+              module_class_factory,
+              :ancestors => ancestors
+          )
+        end
+
+        context 'single payload' do
+          let!(:ancestors) do
+            [
+                FactoryGirl.create(single_payload_module_ancestor_factory)
+            ]
+          end
+
+          it { should be_valid }
+        end
+
+        context 'stage payload and stager payload' do
+          let!(:ancestors) do
+            [
+                FactoryGirl.create(stage_payload_module_ancestor_factory),
+                FactoryGirl.create(stager_payload_module_ancestor_factory)
+            ]
+          end
+
+          it { should be_valid }
+        end
+      end
+    end
+  end
+
+  context 'validations' do
+    context 'ancestors' do
+      context 'count' do
+        subject(:module_class) do
+          FactoryGirl.build(
+              module_class_factory,
+              :ancestors => ancestors,
+              :module_type => module_type,
+              :payload_type => payload_type
+          )
+        end
+
+        before(:each) do
+          # set explicitly so derivation doesn't cause other code path to run
+          module_class.module_type = module_type
+        end
+
+        context 'with payload module_type' do
+          let(:module_type) do
+            'payload'
+          end
+
+          before(:each) do
+            # set explicitly so derivation doesn't cause other code path to run
+            module_class.payload_type = payload_type
+
+            module_class.valid?
+          end
+
+          context 'with single payload_type' do
+            let(:error) do
+              'must have exactly one ancestor for single payload module class'
+            end
+
+            let(:payload_type) do
+              'single'
+            end
+
+
+            context 'with 1 ancestor' do
+              let(:ancestors) do
+                [
+                    FactoryGirl.create(single_payload_module_ancestor_factory)
+                ]
+              end
+
+              it 'should not record error on ancestors' do
+                module_class.errors[:ancestors].should_not include(error)
+              end
+            end
+
+            context 'without 1 ancestor' do
+              let(:ancestors) do
+                []
+              end
+
+              it 'should record error on ancestors' do
+                module_class.errors[:ancestors].should include(error)
+              end
+            end
+          end
+
+          context 'with staged payload_type' do
+            let(:error) do
+              'must have exactly two ancestors (stager + stage) for staged payload module class'
+            end
+
+            let(:payload_type) do
+              'staged'
+            end
+
+            context 'with 2 ancestors' do
+              let(:ancestors) do
+                [
+                    FactoryGirl.create(stage_payload_module_ancestor_factory),
+                    FactoryGirl.create(stager_payload_module_ancestor_factory)
+                ]
+              end
+
+              it 'should not record error on ancestors' do
+                module_class.errors[:ancestors].should_not include(error)
+              end
+            end
+
+            context 'without 2 ancestors' do
+              let(:ancestors) do
+                [
+                    FactoryGirl.create(stage_payload_module_ancestor_factory)
+                ]
+              end
+
+              it 'should record error on ancestors' do
+                module_class.errors[:ancestors].should include(error)
+              end
+            end
+          end
+        end
+
+        context 'without payload module_type' do
+          let(:error) do
+            'must have exactly one ancestor as a non-payload module class'
+          end
+
+          let(:module_type) do
+            FactoryGirl.generate :metasploit_model_non_payload_module_type
+          end
+
+          let(:payload_type) do
+            nil
+          end
+
+          before(:each) do
+            module_class.valid?
+          end
+
+          context 'with 1 ancestor' do
+            let(:ancestors) do
+              [
+                  FactoryGirl.create(non_payload_module_ancestor_factory)
+              ]
+            end
+
+            it 'should not record error on ancestors' do
+              module_class.errors[:ancestors].should_not include(error)
+            end
+          end
+
+          context 'without 1 ancestor' do
+            let(:ancestors) do
+              module_class.errors[:ancestors].should include(error)
+            end
+          end
+        end
+      end
+
+      context 'module_types' do
+        context 'between Metasploit::Model::Module::Ancestor#module_type and Metasploit::Model::Module::Class#module_type' do
+          subject(:module_class) do
+            FactoryGirl.build(
+                module_class_factory,
+                :module_type => module_type,
+                :ancestors => ancestors
+            )
+          end
+
+          def error(module_class, ancestor)
+            "can contain ancestors only with same module_type (#{module_class.module_type}); " \
+            "#{ancestor.full_name} cannot be an ancestor due to its module_type (#{ancestor.module_type})"
+          end
+
+          before(:each) do
+            # Explicitly set module_type so its not derived, which could cause an alternate code path to be tested
+            module_class.module_type = module_type
+
+            module_class.valid?
+          end
+
+          context 'with module_type' do
+            let(:module_type) do
+              FactoryGirl.generate :metasploit_model_module_type
+            end
+
+            context 'with same Metasploit::Model::Module::Ancestor#module_type and Metasploit::Model::Module::Class#module_type' do
+              let(:ancestors) do
+                [
+                    FactoryGirl.create(
+                        module_ancestor_factory,
+                        :module_type => module_type
+                    )
+                ]
+              end
+
+              it 'should not record on ancestors' do
+                module_class.errors[:ancestors].should_not include(error(module_class, ancestors.first))
+              end
+            end
+
+            context 'without same Metasploit::Model::Module::Ancestor#module_type and Metasploit::Model::Module::Class#module_type' do
+              let(:ancestors) do
+                [
+                    FactoryGirl.create(
+                        module_ancestor_factory,
+                        :module_type => 'exploit'
+                    )
+                ]
+              end
+
+              let(:module_type) do
+                'nop'
+              end
+
+              it 'should record error on ancestors' do
+                module_class.errors[:ancestors].should include(error(module_class, ancestors.first))
+              end
+            end
+          end
+
+          context 'without module_type' do
+            # with a nil module_type, module_type will be derived from
+            let(:ancestors) do
+              [
+                  FactoryGirl.create(module_ancestor_factory),
+                  FactoryGirl.create(module_ancestor_factory)
+              ]
+            end
+
+            let(:module_type) do
+              nil
+            end
+
+            it 'should not record errors on ancestors' do
+              ancestor_errors = module_class.errors[:ancestors]
+
+              ancestors.each do |ancestor|
+                ancestor_error = error(module_class, ancestor)
+
+                ancestor_errors.should_not include(ancestor_error)
+              end
+            end
+          end
+        end
+
+        context 'between Metasploit::Model::Module::Ancestor#module_types' do
+          subject(:module_class) do
+            FactoryGirl.build(
+                module_class_factory,
+                :ancestors => ancestors
+            )
+          end
+
+          let(:error) do
+            "can only contain ancestors with one module_type, " \
+            "but contains multiple module_types (#{module_type_set.sort.to_sentence})"
+          end
+
+          before(:each) do
+            module_class.valid?
+          end
+
+          context 'with same Metasploit::Model::Module::Ancestor#module_type' do
+            let(:ancestors) do
+              [
+                  FactoryGirl.create(
+                      module_ancestor_factory,
+                      :module_type => module_type
+                  ),
+                  FactoryGirl.create(
+                      module_ancestor_factory,
+                      :module_type => module_type
+                  )
+              ]
+            end
+
+            let(:module_type) do
+              FactoryGirl.generate :metasploit_model_module_type
+            end
+
+            let(:module_type_set) do
+              Set.new [module_type]
+            end
+
+            it 'should not record error on ancestors' do
+              module_class.errors[:ancestors].should_not include(error)
+            end
+          end
+
+          context 'without same Metasploit::Model::Module::Ancestor#module_type' do
+            let(:ancestors) do
+              module_type_set.collect { |module_type|
+                FactoryGirl.create(
+                    module_ancestor_factory,
+                    :module_type => module_type
+                )
+              }
+            end
+
+            let(:module_types) do
+              [
+                  FactoryGirl.generate(:metasploit_model_module_type),
+                  FactoryGirl.generate(:metasploit_model_module_type)
+              ]
+            end
+
+            let(:module_type_set) do
+              Set.new module_types
+            end
+
+            it 'should record error on ancestors' do
+              module_class.errors[:ancestors].should include(error)
+            end
+          end
+        end
+      end
+
+      context 'payload_types' do
+        subject(:module_class) do
+          FactoryGirl.build(
+              module_class_factory,
+              :ancestors => ancestors,
+              :module_type => module_type
+          )
+        end
+
+        before(:each) do
+          # explicitly set module_type so it is not derived from ancestors
+          module_class.module_type = module_type
+        end
+
+        context "with 'payload' Metasploit::Model::Module::Class#module_type" do
+          let(:module_type) do
+            'payload'
+          end
+
+          let(:ancestors) do
+            [
+                ancestor
+            ]
+          end
+
+          context 'with Metasploit::Model::Module::Class#payload_type' do
+            before(:each) do
+              # Explicitly set payload_type so it is not derived from ancestors
+              module_class.payload_type = payload_type
+
+              module_class.valid?
+            end
+
+            context 'single' do
+              let(:error) do
+                "cannot have an ancestor (#{ancestor.full_name}) " \
+                "with payload_type (#{ancestor.payload_type}) " \
+                "for class payload_type (#{payload_type})"
+              end
+
+              let(:payload_type) do
+                'single'
+              end
+
+              context "with 'single' Metasploit::Model::Module::Ancestor#payload_type" do
+                let(:ancestor) do
+                  FactoryGirl.create(single_payload_module_ancestor_factory)
+                end
+
+                it 'should not record error on ancestors' do
+                  module_class.errors[:ancestors].should_not include(error)
+                end
+              end
+
+              context "without 'single' Metasploit::Model::Module::Ancestor#payload_type" do
+                let(:ancestor) do
+                  FactoryGirl.create(stage_payload_module_ancestor_factory)
+                end
+
+                it 'should record error on ancestors' do
+                  module_class.errors[:ancestors].should include(error)
+                end
+              end
+            end
+
+            context 'staged' do
+              let(:payload_type) do
+                'staged'
+              end
+
+              context "Metasploit::Model::Module::Ancestor#payload_type" do
+                let(:few_error) do
+                  "needs exactly one ancestor with payload_type (#{ancestor_payload_type}), " \
+                  "but there are none."
+                end
+
+                let(:many_error) do
+                  "needs exactly one ancestor with payload_type (#{ancestor_payload_type}), " \
+                  "but there are #{ancestors.count} (#{ancestors.map(&:full_name).sort.to_sentence})"
+                end
+
+                context 'single' do
+                  context 'without zero' do
+                    let(:ancestor) do
+                      FactoryGirl.create(single_payload_module_ancestor_factory)
+                    end
+
+                    let(:ancestors) do
+                      [
+                          ancestor
+                      ]
+                    end
+
+                    let(:error) do
+                      "cannot have ancestors (#{ancestor.full_name}) " \
+                      "with payload_type (#{ancestor.payload_type}) " \
+                      "for class payload_type (#{payload_type}); " \
+                      "only one stage and one stager ancestor is allowed"
+                    end
+
+                    it 'should record error on ancestors' do
+                      module_class.valid?
+
+                      module_class.errors[:ancestors].should include(error)
+                    end
+                  end
+                end
+
+                context 'stage' do
+                  let(:ancestor_payload_type) do
+                    'stage'
+                  end
+
+                  context 'with < 1' do
+                    # 1 stager and 0 stages, so stages count < 1
+                    let(:ancestors) do
+                      [
+                          FactoryGirl.create(stager_payload_module_ancestor_factory)
+                      ]
+                    end
+
+                    it 'should record error on ancestors' do
+                      module_class.errors[:ancestors].should include(few_error)
+                    end
+                  end
+
+                  context 'with 1' do
+                    # 1 stager and 1 stage, so stages count == 1
+                    let(:ancestors) do
+                      [
+                          FactoryGirl.create(stager_payload_module_ancestor_factory),
+                          FactoryGirl.create(stage_payload_module_ancestor_factory)
+                      ]
+                    end
+
+                    it 'should not record error on ancestors' do
+                      module_class.errors[:ancestors].should_not include(few_error)
+                      module_class.errors[:ancestors].should_not include(many_error)
+                    end
+                  end
+
+                  context 'with > 1' do
+                    # 0 stager, 2 stages, so stages count > 1
+                    let(:ancestors) do
+                      FactoryGirl.create_list(stage_payload_module_ancestor_factory, 2)
+                    end
+
+                    it 'should record error on ancestors' do
+                      module_class.errors[:ancestors].should include(many_error)
+                    end
+                  end
+                end
+
+                context 'stager' do
+                  let(:ancestor_payload_type) do
+                    'stager'
+                  end
+
+                  context 'with < 1' do
+                    # 0 stager and 1 stages, so stagers count < 1
+                    let(:ancestors) do
+                      [
+                          FactoryGirl.create(stage_payload_module_ancestor_factory)
+                      ]
+                    end
+
+                    it 'should record error on ancestors' do
+                      module_class.errors[:ancestors].should include(few_error)
+                    end
+                  end
+
+                  context 'with 1' do
+                    # 1 stager and 1 stage, so stagers count == 1
+                    let(:ancestors) do
+                      [
+                          FactoryGirl.create(stager_payload_module_ancestor_factory),
+                          FactoryGirl.create(stage_payload_module_ancestor_factory)
+                      ]
+                    end
+
+                    it 'should not record error on ancestors' do
+                      module_class.errors[:ancestors].should_not include(few_error)
+                      module_class.errors[:ancestors].should_not include(many_error)
+                    end
+                  end
+
+                  context 'with > 1' do
+                    # 2 stagers, 0 stages, so stagers count > 1
+                    let(:ancestors) do
+                      FactoryGirl.create_list(stager_payload_module_ancestor_factory, 2)
+                    end
+
+                    it 'should record error on ancestors' do
+                      module_class.errors[:ancestors].should include(many_error)
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+
+        context "without 'payload' Metasploit::Model::Module::Class#module_type" do
+          let(:ancestors) do
+            [
+                ancestor
+            ]
+          end
+
+          let(:error) do
+            "cannot have an ancestor (#{ancestor.full_name}) " \
+            "with a payload_type (#{ancestor.payload_type}) " \
+            "for class module_type (#{module_type})"
+          end
+
+          let(:module_type) do
+            FactoryGirl.generate :metasploit_model_non_payload_module_type
+          end
+
+          before(:each) do
+            module_class.valid?
+          end
+
+          context 'with Metasploit::Model::Module::Ancestor#payload_type' do
+            let(:ancestor) do
+              FactoryGirl.create(payload_module_ancestor_factory)
+            end
+
+            it 'should record error on ancestors' do
+              module_class.errors[:ancestors].should include(error)
+            end
+          end
+
+          context 'without Metasploit::Model::Module::Ancestor#payload_type' do
+            let(:ancestor) do
+              FactoryGirl.create(non_payload_module_ancestor_factory)
+            end
+
+            it 'should not record error on ancestors' do
+              module_class.errors[:ancestors].should_not include(error)
+            end
+          end
+        end
+      end
+    end
+
+    context 'validates module_type inclusion in Metasploit::Model::Module::Ancestor::MODULE_TYPES' do
+      subject(:module_class) do
+        FactoryGirl.build(
+            module_class_factory,
+            :ancestors => [],
+            :module_type => module_type
+        )
+      end
+
+      let(:error) do
+        'is not included in the list'
+      end
+
+      before(:each) do
+        module_class.module_type = module_type
+      end
+
+      Metasploit::Model::Module::Type::ALL.each do |context_module_type|
+        context "with #{context_module_type}" do
+          let(:module_type) do
+            context_module_type
+          end
+
+          it 'should not record error on module_type' do
+            module_class.valid?
+
+            module_class.errors[:module_type].should_not include(error)
+          end
+        end
+      end
+
+      context 'without module_type' do
+        let(:module_type) do
+          nil
+        end
+
+        it { should_not be_valid }
+
+        it 'should record error on module_type' do
+          module_class.valid?
+
+          module_class.errors[:module_type].should include(error)
+        end
+      end
+    end
+
+    context 'payload_type' do
+      subject(:module_class) do
+        FactoryGirl.build(
+            module_class_factory,
+            :module_type => module_type
+        )
+      end
+
+      before(:each) do
+        module_class.payload_type = payload_type
+      end
+
+      context 'with payload' do
+        let(:module_type) do
+          'payload'
+        end
+
+        context 'with payload_type' do
+          subject(:module_class) do
+            FactoryGirl.build(
+                module_class_factory,
+                # Set explicitly so not derived from module_type and payload_type in factory, which will fail for the
+                # invalid payload_type test.
+                :ancestors => [],
+                :module_type => module_type,
+                :payload_type => payload_type
+            )
+          end
+
+          let(:error) do
+            'is not in list'
+          end
+
+          before(:each) do
+            # Set explicitly so not derived
+            module_class.payload_type = payload_type
+          end
+
+          context 'single' do
+            let(:payload_type) do
+              'single'
+            end
+
+            it 'should not record error' do
+              module_class.valid?
+
+              module_class.errors[:payload_type].should_not include(error)
+            end
+          end
+
+          context 'staged' do
+            let(:payload_type) do
+              'staged'
+            end
+
+            it 'should not record error on payload_type' do
+              module_class.valid?
+
+              module_class.errors[:payload_type].should_not include(error)
+            end
+          end
+
+          context 'other' do
+            let(:payload_type) do
+              'invalid_payload_type'
+            end
+
+            it 'should record error on payload_type' do
+              module_class.valid?
+
+              module_class.errors[:payload_type].should_not be_empty
+            end
+          end
+        end
+      end
+
+      context 'without payload' do
+        let(:error) do
+          'must be nil'
+        end
+
+        let(:module_type) do
+          FactoryGirl.generate :metasploit_model_non_payload_module_type
+        end
+
+        before(:each) do
+          module_class.payload_type = payload_type
+        end
+
+        context 'with payload_type' do
+          let(:payload_type) do
+            FactoryGirl.generate :metasploit_model_module_class_payload_type
+          end
+
+          it 'should record error on payload_type' do
+            module_class.valid?
+
+            module_class.errors[:payload_type].should include(error)
+          end
+        end
+
+        context 'without payload_type' do
+          let(:payload_type) do
+            nil
+          end
+
+          it 'should not error on payload_type' do
+            module_class.valid?
+
+            module_class.errors[:payload_type].should_not include(error)
+          end
+
+        end
+      end
+    end
+
+    it { should validate_presence_of(:rank) }
+
+    context 'with nil derived_reference_name' do
+      before(:each) do
+        module_class.stub(:derived_reference_name => nil)
+      end
+
+      it { should validate_presence_of(:reference_name) }
+    end
+  end
+
+  context '#derived_module_type' do
+    subject(:derived_module_type) do
+      module_class.derived_module_type
+    end
+
+    context 'ancestors' do
+      before(:each) do
+        module_class.ancestors = ancestors
+      end
+
+      context 'empty' do
+        let(:ancestors) do
+          []
+        end
+
+        it { should be_nil }
+      end
+
+      context 'non-empty' do
+        context 'with same Metasploit::Model::Module::Ancestor#module_type' do
+          let(:ancestors) do
+            FactoryGirl.create_list(module_ancestor_factory, 2, :module_type => module_type)
+          end
+
+          let(:module_type) do
+            FactoryGirl.generate :metasploit_model_module_type
+          end
+
+          it 'should return shared module_type' do
+            derived_module_type.should == module_type
+          end
+        end
+
+        context 'with different Metasploit::Model::Module;:Ancestor#module_type' do
+          let(:ancestors) do
+            FactoryGirl.create_list(module_ancestor_factory, 2)
+          end
+
+          it 'should return nil because there is no consensus' do
+            derived_module_type.should be_nil
+          end
+        end
+      end
+    end
+  end
+
+  context '#derived_payload_type' do
+    subject(:derived_payload_type) do
+      module_class.derived_payload_type
+    end
+
+    before(:each) do
+      module_class.module_type = module_type
+    end
+
+    context 'with payload' do
+      let(:module_type) do
+        'payload'
+      end
+
+      before(:each) do
+        module_class.ancestors = ancestors
+      end
+
+      context 'with 1 ancestor' do
+        let(:ancestors) do
+          [
+              FactoryGirl.create(
+                  module_ancestor_factory,
+                  :module_type => 'payload',
+                  :payload_type => payload_type
+              )
+          ]
+        end
+
+        context 'with single' do
+          let(:payload_type) do
+            'single'
+          end
+
+          it { should == 'single' }
+        end
+
+        context 'without single' do
+          let(:payload_type) do
+            'stage'
+          end
+
+          it { should be_nil }
+        end
+      end
+
+      context 'with 2 ancestors' do
+        context 'with stager and stage' do
+          let(:ancestors) do
+            ['stager', 'stage'].collect { |payload_type|
+              FactoryGirl.create(
+                  payload_module_ancestor_factory,
+                  :payload_type => payload_type
+              )
+            }
+          end
+
+          it { should == 'staged' }
+        end
+
+        context 'without stager and stage' do
+          let(:ancestors) do
+            FactoryGirl.create_list(
+                payload_module_ancestor_factory,
+                2,
+                :payload_type => 'stage'
+            )
+          end
+
+          it { should be_nil }
+        end
+      end
+    end
+
+    context 'without payload' do
+      let(:module_type) do
+        FactoryGirl.generate :metasploit_model_non_payload_module_type
+      end
+    end
+  end
+
+  context '#derived_reference_name' do
+    subject(:derived_reference_name) do
+      module_class.derived_reference_name
+    end
+
+    before(:each) do
+      module_class.module_type = module_type
+    end
+
+    context 'with payload' do
+      let(:module_type) do
+        'payload'
+      end
+
+      before(:each) do
+        module_class.payload_type = payload_type
+      end
+
+      context 'with single' do
+        let(:payload_type) do
+          'single'
+        end
+
+        it 'should call #derived_single_payload_reference_name' do
+          module_class.should_receive(:derived_single_payload_reference_name)
+
+          derived_reference_name
+        end
+      end
+
+      context 'with staged' do
+        let(:payload_type) do
+          'staged'
+        end
+
+        it 'should call #derived_staged_payload_reference_name' do
+          module_class.should_receive(:derived_staged_payload_reference_name)
+
+          derived_reference_name
+        end
+      end
+
+      context 'without single or staged' do
+        let(:payload_type) do
+          'invalid_payload_type'
+        end
+
+        it { should be_nil }
+      end
+    end
+
+    context 'without payload' do
+      let(:module_type) do
+        FactoryGirl.generate :metasploit_model_non_payload_module_type
+      end
+
+      before(:each) do
+        module_class.ancestors = ancestors
+      end
+
+      context 'with 1 ancestor' do
+        let(:ancestor) do
+          FactoryGirl.create(non_payload_module_ancestor_factory)
+        end
+
+        let(:ancestors) do
+          [
+              ancestor
+          ]
+        end
+
+        it 'should return reference_name of ancestor' do
+          derived_reference_name.should == ancestor.reference_name
+        end
+      end
+
+      context 'without 1 ancestor' do
+        let(:ancestors) do
+          FactoryGirl.create_list(module_ancestor_factory, 2)
+        end
+
+        it { should be_nil }
+      end
+    end
+  end
+
+  context '#derived_single_payload_reference_name' do
+    subject(:derived_single_payload_reference_name) do
+      module_class.send(:derived_single_payload_reference_name)
+    end
+
+    before(:each) do
+      module_class.ancestors = ancestors
+    end
+
+    context 'with 1 ancestor' do
+      let(:ancestor) do
+        FactoryGirl.create(
+            payload_module_ancestor_factory,
+            :payload_type => payload_type
+        )
+      end
+
+      let(:ancestors) do
+        [
+            ancestor
+        ]
+      end
+
+      context 'with single' do
+        let(:payload_type) do
+          'single'
+        end
+
+        before(:each) do
+          ancestor.reference_name = reference_name
+        end
+
+        context 'with reference_name' do
+          let(:payload_name) do
+            'payload/name'
+          end
+
+          let(:payload_type_directory) do
+            'singles'
+          end
+
+          let(:reference_name) do
+            "#{payload_type_directory}/#{payload_name}"
+          end
+
+          it 'should return Metasploit::Model::Module::Ancestor#payload_name' do
+            expect(derived_single_payload_reference_name).to eq(payload_name)
+          end
+        end
+
+        context 'without reference_name' do
+          let(:reference_name) do
+            nil
+          end
+        end
+
+      end
+
+      context 'without single' do
+        let(:payload_type) do
+          'stage'
+        end
+
+        it { should be_nil }
+      end
+    end
+
+    context 'without 1 ancestor' do
+      let(:ancestors) do
+        []
+      end
+
+      it { should be_nil }
+    end
+  end
+
+  context '#derived_staged_payload_reference_name' do
+    subject(:derived_staged_payload_reference_name) do
+      module_class.send(:derived_staged_payload_reference_name)
+    end
+
+    before(:each) do
+      module_class.ancestors = ancestors
+    end
+
+    context 'with 2 ancestors' do
+      context 'with 1 stage' do
+        let(:stage_ancestor) do
+          FactoryGirl.create(stage_payload_module_ancestor_factory)
+        end
+
+        before(:each) do
+          stage_ancestor.reference_name = stage_reference_name
+        end
+
+        context 'with reference_name' do
+          let(:stage_payload_name) do
+            'payload/name'
+          end
+
+          let(:stage_reference_name) do
+            "#{stage_type_directory}/#{stage_payload_name}"
+          end
+
+          let(:stage_type_directory) do
+            'stages'
+          end
+
+          context 'with 1 stager' do
+            let(:ancestors) do
+              [
+                  stager_ancestor,
+                  stage_ancestor
+              ]
+            end
+
+            let(:stager_ancestor) do
+              FactoryGirl.create(stager_payload_module_ancestor_factory)
+            end
+
+            before(:each) do
+              stager_ancestor.handler_type = stager_handler_type
+            end
+
+            context 'with handler_type' do
+              let(:stager_handler_type) do
+                FactoryGirl.generate :metasploit_model_module_handler_type
+              end
+
+              it 'should be <stage.payload_name>/<stager.handler_type>' do
+                expect(derived_staged_payload_reference_name).to eq("#{stage_payload_name}/#{stager_handler_type}")
+              end
+            end
+
+            context 'without handler_type' do
+              let(:stager_handler_type) do
+                nil
+              end
+
+              it { should be_nil }
+            end
+          end
+
+          context 'without 1 stager' do
+            let(:ancestors) do
+              [
+                  stage_ancestor,
+                  FactoryGirl.create(single_payload_module_ancestor_factory)
+              ]
+            end
+
+            it { should be_nil }
+          end
+        end
+
+        context 'without reference_name' do
+          let(:ancestors) do
+            [
+                FactoryGirl.create(stager_payload_module_ancestor_factory),
+                stage_ancestor
+            ]
+          end
+
+          let(:stage_reference_name) do
+            nil
+          end
+
+          it { should be_nil }
+        end
+      end
+
+      context 'without 1 stage' do
+        let(:ancestors) do
+          FactoryGirl.create_list(stager_payload_module_ancestor_factory, 2)
+        end
+
+        it { should be_nil }
+      end
+    end
+
+    context 'without 2 ancestors' do
+      let(:ancestors) do
+        FactoryGirl.create_list(module_ancestor_factory, 3)
+      end
+
+      it { should be_nil }
+    end
+  end
+
+  context '#payload?' do
+    subject(:payload?) do
+      module_class.payload?
+    end
+
+    # use new instead of factory so that payload? won't be called in the background to show this context supplies
+    # coverage
+    let(:module_class) do
+      module_class_class.new
+    end
+
+    before(:each) do
+      module_class.module_type = module_type
+    end
+
+    context 'with payload' do
+      let(:module_type) do
+        'payload'
+      end
+
+      it { should be_true }
+    end
+
+    context 'without payload' do
+      let(:module_type) do
+        FactoryGirl.generate :metasploit_model_non_payload_module_type
+      end
+
+      it { should be_false }
+    end
+  end
+
+  context '#staged_payload_type_count' do
+    subject(:staged_payload_type_count) do
+      module_class.send(
+          :staged_payload_type_count,
+          ancestors_by_payload_type,
+          ancestor_payload_type
+      )
+    end
+
+    let(:ancestor_payload_type) do
+      FactoryGirl.generate :metasploit_model_module_ancestor_payload_type
+    end
+
+    before(:each) do
+      staged_payload_type_count
+    end
+
+    context 'with ancestors with payload_type' do
+      context 'with 1' do
+        let(:ancestors_by_payload_type) do
+          {
+              ancestor_payload_type => FactoryGirl.create_list(
+                  payload_module_ancestor_factory,
+                  1,
+                  :payload_type => ancestor_payload_type
+              )
+          }
+        end
+
+        it 'should not record error on ancestors' do
+          module_class.errors[:ancestors].should be_empty
+        end
+      end
+
+      context 'without 1' do
+        let(:ancestors_by_payload_type) do
+          {
+              ancestor_payload_type => payload_type_ancestors
+          }
+        end
+
+        let(:full_name_sentence) do
+          payload_type_ancestors.map(&:full_name).sort.to_sentence
+        end
+
+        let(:payload_type_ancestors) do
+          FactoryGirl.create_list(
+              payload_module_ancestor_factory,
+              payload_type_ancestor_count,
+              :payload_type => ancestor_payload_type
+          )
+        end
+
+        let(:payload_type_ancestor_count) do
+          2
+        end
+
+        let(:error) do
+          "needs exactly one ancestor with payload_type (#{ancestor_payload_type}), " \
+          "but there are #{payload_type_ancestor_count} (#{full_name_sentence})"
+        end
+
+        it 'should record error on ancestors' do
+          module_class.errors[:ancestors].should include(error)
+        end
+      end
+    end
+
+    context 'without ancestors with payload_type' do
+      let(:ancestors_by_payload_type) do
+        {}
+      end
+
+      let(:error) do
+        "needs exactly one ancestor with payload_type (#{ancestor_payload_type}), but there are none."
+      end
+
+      it 'should record error on ancestors' do
+        module_class.errors[:ancestors].should include(error)
+      end
+    end
+  end
+end