metasploit-model 0.28.0 → 0.29.0

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

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

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

@@ -1,92 +0,0 @@
-Metasploit::Model::Spec.shared_examples_for 'Module::Rank' do
-  subject(:module_rank) do
-    # need non-factory subject since ranks are only seeded and so a sequence.
-    # The sequence elements can't be used as they are frozen.
-    module_rank_class.new
-  end
-
-  context 'CONSTANTS' do
-    context 'NAME_BY_NUMBER' do
-      subject(:name_by_numnber) do
-        described_class::NAME_BY_NUMBER
-      end
-
-      its([0]) { should == 'Manual' }
-      its([100]) { should == 'Low' }
-      its([200]) { should == 'Average' }
-      its([300]) { should == 'Normal' }
-      its([400]) { should == 'Good' }
-      its([500]) { should == 'Great' }
-      its([600]) { should == 'Excellent' }
-    end
-
-    context 'NAME_REGEXP' do
-      subject(:name_regexp) do
-        described_class::NAME_REGEXP
-      end
-
-      it 'should not match a #name starting with a lowercase letter' do
-        name_regexp.should_not match('good')
-      end
-
-      it 'should match a #name starting with a capital letter' do
-        name_regexp.should match('Good')
-      end
-
-      it 'should not match a #name with a space' do
-        name_regexp.should_not match('Super Effective')
-      end
-    end
-
-    context 'NUMBER_BY_NAME' do
-      subject(:number_by_name) do
-        described_class::NUMBER_BY_NAME
-      end
-
-      its(['Manual']) { should == 0 }
-      its(['Low']) { should == 100 }
-      its(['Average']) { should == 200 }
-      its(['Normal']) { should == 300 }
-      its(['Good']) { should == 400 }
-      its(['Great']) { should == 500 }
-      its(['Excellent']) { should == 600 }
-    end
-  end
-
-  context 'mass assignment security' do
-    it { should allow_mass_assignment_of(:name) }
-    it { should allow_mass_assignment_of(:number) }
-  end
-
-  context 'search' do
-    context 'attributes' do
-      it_should_behave_like 'search_attribute', :name, :type => :string
-      it_should_behave_like 'search_attribute', :number, :type => :integer
-    end
-  end
-
-  context 'validations' do
-    context 'name' do
-      it { should ensure_inclusion_of(:name).in_array(described_class::NUMBER_BY_NAME.keys) }
-
-      context 'format' do
-        it 'should not allow #name starting with a lowercase letter' do
-          module_rank.should_not allow_value('good').for(:name)
-        end
-
-        it 'should allow #name starting with a capital letter' do
-          module_rank.should allow_value('Good').for(:name)
-        end
-
-        it 'should not allow #name with a space' do
-          module_rank.should_not allow_value('Super Effective').for(:name)
-        end
-      end
-    end
-
-    context 'number' do
-      it { should ensure_inclusion_of(:number).in_array(described_class::NUMBER_BY_NAME.values) }
-      it { should validate_numericality_of(:number).only_integer }
-    end
-  end
-end

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

@@ -1,16 +0,0 @@
-Metasploit::Model::Spec.shared_examples_for 'Module::Reference' do
-  context 'factories' do
-    context module_reference_factory.to_s do
-      subject(module_reference_factory) do
-        FactoryGirl.build(module_reference_factory)
-      end
-
-      it { should be_valid }
-    end
-  end
-
-  context 'validations' do
-    it { should validate_presence_of :module_instance }
-    it { should validate_presence_of :reference }
-  end
-end

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

@@ -1,29 +0,0 @@
-
-Metasploit::Model::Spec.shared_examples_for 'Module::Target' do
-  context 'factories' do
-    context module_target_factory do
-      subject(module_target_factory) do
-        FactoryGirl.build(module_target_factory)
-      end
-
-      it { should be_valid }
-    end
-  end
-
-  context 'mass assignment security' do
-    it { should allow_mass_assignment_of(:name) }
-  end
-
-  context 'search' do
-    context 'attributes' do
-      it_should_behave_like 'search_attribute', :name, :type => :string
-    end
-  end
-
-  context 'validations' do
-    it { should validate_presence_of(:module_instance) }
-    it { should validate_presence_of(:name) }
-    it { should validate_presence_of :target_architectures }
-    it { should validate_presence_of :target_platforms }
-  end
-end

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

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

data/spec/support/shared/examples/metasploit/model/module/target/platform.rb

@@ -1,56 +0,0 @@
-Metasploit::Model::Spec.shared_examples_for 'Module::Target::Platform' do
-  context 'factories' do
-    context module_target_platform_factory do
-      subject(module_target_platform_factory) do
-        FactoryGirl.build(module_target_platform_factory)
-      end
-
-      it { should be_valid }
-
-      context '#module_target' do
-        subject(:module_target) do
-          send(module_target_platform_factory).module_target
-        end
-
-        it { should be_valid }
-
-        context '#module_instance' do
-          subject(:module_instance) do
-            module_target.module_instance
-          end
-
-          it { should be_valid }
-
-          context '#targets' do
-            subject(:targets) do
-              module_instance.targets
-            end
-
-            its(:length) { should == 1 }
-
-            it 'should include #module_target' do
-              expect(targets).to include module_target
-            end
-          end
-        end
-
-        context '#target_platforms' do
-          subject(:target_platforms) do
-            module_target.target_platforms
-          end
-
-          its(:length) { should == 1}
-
-          it "should include #{module_target_platform_factory}" do
-            expect(target_platforms).to include send(module_target_platform_factory)
-          end
-        end
-      end
-    end
-  end
-
-  context 'validations' do
-    it { should validate_presence_of :module_target }
-    it { should validate_presence_of :platform }
-  end
-end

data/spec/support/shared/examples/metasploit/model/platform.rb

@@ -1,213 +0,0 @@
-Metasploit::Model::Spec.shared_examples_for 'Platform' do
-  platform_sequence = "#{factory_namespace}_#{relative_variable_name}"
-
-  subject(:platform) do
-    FactoryGirl.generate platform_sequence
-  end
-
-  context 'CONSTANTS' do
-    context 'SEED_RELATIVE_NAME_TRIE' do
-      subject(:seed_relative_name_tree) do
-        described_class::SEED_RELATIVE_NAME_TREE
-      end
-
-      it { should include('AIX') }
-      it { should include('Android') }
-      it { should include('BSD') }
-      it { should include('BSDi') }
-      it { should include('Cisco') }
-      it { should include('Firefox') }
-      it { should include('FreeBSD') }
-      it { should include('HPUX') }
-      it { should include('IRIX') }
-      it { should include('Java') }
-      it { should include('Javascript') }
-      it { should include('Linux') }
-      it { should include('NetBSD') }
-      it { should include('Netware') }
-      it { should include('NodeJS') }
-      it { should include('OpenBSD') }
-      it { should include('OSX') }
-      it { should include('PHP') }
-      it { should include('Python') }
-      it { should include('Ruby') }
-
-      context "['Solaris']" do
-        subject(:solaris) do
-          seed_relative_name_tree['Solaris']
-        end
-
-        it { should include('4') }
-        it { should include('5') }
-        it { should include('6') }
-        it { should include('7') }
-        it { should include('8') }
-        it { should include('9') }
-        it { should include('10') }
-      end
-
-      context "['Windows']" do
-        subject(:windows) do
-          seed_relative_name_tree['Windows']
-        end
-
-        it { should include('95') }
-
-        context "['98']" do
-          subject(:ninety_eight) do
-            windows['98']
-          end
-
-          it { should include('FE') }
-          it { should include('SE') }
-        end
-
-        it { should include('ME') }
-
-        context "['NT']" do
-          subject(:nt) do
-            windows['NT']
-          end
-
-          it { should include('SP0') }
-          it { should include('SP1') }
-          it { should include('SP2') }
-          it { should include('SP3') }
-          it { should include('SP4') }
-          it { should include('SP5') }
-          it { should include('SP6') }
-          it { should include('SP6a') }
-        end
-
-        context "['2000']" do
-          subject(:two_thousand) do
-            windows['2000']
-          end
-
-          it { should include('SP0') }
-          it { should include('SP1') }
-          it { should include('SP2') }
-          it { should include('SP3') }
-          it { should include('SP4') }
-        end
-
-        context "['XP']" do
-          subject(:xp) do
-            windows['XP']
-          end
-
-          it { should include('SP0') }
-          it { should include('SP1') }
-          it { should include('SP2') }
-          it { should include('SP3') }
-        end
-
-        context "['2003']" do
-          subject(:two_thousand_three) do
-            windows['2003']
-          end
-
-          it { should include('SP0') }
-          it { should include('SP1') }
-        end
-
-        context "['Vista']" do
-          subject(:vista) do
-            windows['Vista']
-          end
-
-          it { should include('SP0') }
-          it { should include('SP1') }
-        end
-
-        it { should include('7') }
-      end
-
-      it { should include('UNIX') }
-    end
-  end
-
-  context 'derivations' do
-    subject(:platform) do
-      # can't use seeded platforms because they are frozen
-      # have to tap to bypass mass-assignment security
-      platform_class.new.tap { |platform|
-        platform.parent = windows
-        # need to use a real name or derivation won't be valid because it won't be in fully_qualified_names.
-        platform.relative_name = 'XP'
-      }
-    end
-
-    let(:windows) do
-      platform_class.all.find { |platform|
-        # need to use a real name or derivation won't be valid because it won't be in fully_qualified_names.
-        platform.fully_qualified_name == 'Windows'
-      }
-    end
-
-    it_should_behave_like 'derives', :fully_qualified_name, :validates => true
-  end
-
-  context 'mass assignment security' do
-    it { should allow_mass_assignment_of(:relative_name) }
-  end
-
-  context 'search' do
-    context 'attributes' do
-      it_should_behave_like 'search_attribute',
-                            :fully_qualified_name,
-                            type: {
-                                set: :string
-                            }
-    end
-  end
-
-  context 'validations' do
-    subject(:platform) do
-      # can't use seeded platforms because they are frozen
-      platform_class.new
-    end
-
-    it { should validate_presence_of(:relative_name) }
-  end
-
-  context '#derived_fully_qualified_name' do
-    subject(:derived_fully_qualified_name) do
-      platform.derived_fully_qualified_name
-    end
-
-    context 'with #relative_name' do
-      context 'with #parent' do
-        let(:platform) do
-          base_class.all.select { |platform|
-            platform.parent.present?
-          }.sample
-        end
-
-        it "should be '<parent.fully_qualified_name> <relative_name>'" do
-          derived_fully_qualified_name.should == "#{platform.parent.fully_qualified_name} #{platform.relative_name}"
-        end
-      end
-
-      context 'without #parent' do
-        let(:platform) do
-          base_class.all.reject { |platform|
-            platform.parent.present?
-          }.sample
-        end
-
-        it 'should be #relative_name' do
-          derived_fully_qualified_name.should == platform.relative_name
-        end
-      end
-    end
-
-    context 'without #relative_name' do
-      let(:platform) do
-        platform_class.new
-      end
-
-      it { should be_nil }
-    end
-  end
-end