metasploit-model 0.24.1-java

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

@@ -0,0 +1,36 @@
+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

@@ -0,0 +1,92 @@
+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

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,29 @@
+
+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

@@ -0,0 +1,56 @@
+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

@@ -0,0 +1,56 @@
+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

@@ -0,0 +1,213 @@
+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