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

data/spec/support/shared/examples/metasploit/model/module/instance/is_not_stanced_with_module_type.rb

@@ -0,0 +1,22 @@
+shared_examples_for 'Metasploit::Model::Module::Instance is not stanced with module_type' do |context_module_type|
+  context "with #{context_module_type.inspect}" do
+    # define as a let so that lets from outer context can access option to set detail.
+    let(:module_type) do
+      context_module_type
+    end
+
+    it "should have #{context_module_type.inspect} for module_class.module_type" do
+      module_instance.module_class.module_type.should == module_type
+    end
+
+    it { should_not be_stanced }
+
+    context 'with nil stance' do
+      let(:stance) do
+        nil
+      end
+
+      it { should be_valid }
+    end
+  end
+end

data/spec/support/shared/examples/metasploit/model/module/instance/is_stanced_with_module_type.rb

@@ -0,0 +1,38 @@
+shared_examples_for 'Metasploit::Model::Module::Instance is stanced with module_type' do |context_module_type|
+  context "with #{context_module_type.inspect}" do
+    # define as a let so that lets from outer context can access option to set detail.
+    let(:module_type) do
+      context_module_type
+    end
+
+    it "should have #{context_module_type.inspect} for module_class.module_type" do
+      module_instance.module_class.module_type.should == module_type
+    end
+
+    it { should be_stanced }
+
+    context 'with nil stance' do
+      let(:stance) do
+        nil
+      end
+
+      it { should be_invalid }
+    end
+
+    context "with 'aggresive' stance" do
+      let(:stance) do
+        'aggressive'
+      end
+
+      it { should be_valid }
+    end
+
+    context "with 'passive' stance" do
+      let(:stance) do
+        'passive'
+      end
+
+      it { should be_valid }
+    end
+  end
+end

data/spec/support/shared/examples/metasploit/model/module/instance/validates/dynamic_length_of.rb

@@ -0,0 +1,131 @@
+shared_examples_for 'Metasploit::Model::Module::Instance validates dynamic length of' do |attribute, options={}|
+  options.assert_valid_keys(:options_by_extreme_by_module_type, :factory)
+  options_by_extreme_by_module_type = options.fetch(:options_by_extreme_by_module_type)
+  attribute_factory = options.fetch(:factory)
+
+  context attribute do
+    context 'errors' do
+      subject(:attribute_errors) do
+        module_instance.errors[attribute]
+      end
+
+      let(attribute) do
+        FactoryGirl.build_list(
+            attribute_factory,
+            attribute_count,
+            module_instance: module_instance
+        )
+      end
+
+      let(:attribute_count) do
+        Random.rand(attribute_count_range)
+      end
+
+      let(:error) do
+        # need to use human_attribute_name to emulate error translation process from ActiveModel::Errors.
+        I18n.translate!(
+            error_key,
+            count: extreme_value,
+            attribute: human_attribute_name
+        )
+      end
+
+      let(:error_key) do
+        "metasploit.model.errors.models.metasploit/model/module/instance.attributes.#{attribute}.#{error_type}"
+      end
+
+      let(:human_attribute_name) do
+        module_instance.class.human_attribute_name(attribute)
+      end
+
+      before(:each) do
+        module_instance.send("#{attribute}=", send(attribute))
+        module_instance.module_class.module_type = module_type
+        # populate attribute_errors
+        module_instance.valid?
+      end
+
+      context '#module_type' do
+        Metasploit::Model::Module::Type::ALL.each do |module_type|
+          options_by_extreme = options_by_extreme_by_module_type.fetch(module_type)
+
+          options_by_extreme.assert_valid_keys(:maximum, :minimum)
+
+          maximum_options = options_by_extreme.fetch(:maximum)
+          maximum_options.assert_valid_keys(:extreme, :error_type)
+          maximum = maximum_options.fetch(:extreme)
+
+          minimum_options = options_by_extreme.fetch(:minimum)
+          minimum_options.assert_valid_keys(:extreme, :error_type)
+          minimum = minimum_options.fetch(:extreme)
+
+          context "with #{module_type.inspect}" do
+            # has to be captured in a let so before(:each) in outer context can use it
+            let(:module_type) do
+              module_type
+            end
+
+            if minimum > 0
+              # fetch error_type here because it is only needs to be given if minimum > 0.
+              minimum_error_type = minimum_options.fetch(:error_type)
+
+              context "below minimum (#{minimum})" do
+                let(:attribute_count_range) do
+                  0 ... minimum
+                end
+
+                let(:error_type) do
+                  minimum_error_type
+                end
+
+                let(:extreme_value) do
+                  minimum
+                end
+
+                it { should include(error) }
+              end
+            end
+
+            clamped_minimum = 2 * minimum + 1
+            # maximum may be infinity, so need to clamp it to a more realistic value that can be built from factories
+            clamped_maximum = [maximum, clamped_minimum].min
+
+            if maximum > minimum
+              context "in range (#{minimum} .. #{maximum})" do
+                let(:attribute_count_range) do
+                  minimum .. clamped_maximum
+                end
+
+                it { should be_empty }
+              end
+            end
+
+            if maximum < Float::INFINITY
+              # fetch error_type here because it only needs to be given if maximum is not ∞
+              maximum_error_type = maximum_options.fetch(:error_type)
+
+              context "above maximum (#{maximum})" do
+                above_maximum = maximum + 1
+
+                let(:attribute_count_range) do
+                  # 2 to double the range
+                  above_maximum .. (2 * above_maximum)
+                end
+
+                let(:error_type) do
+                  maximum_error_type
+                end
+
+                let(:extreme_value) do
+                  maximum
+                end
+
+                it { should include(error) }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,493 @@
+Metasploit::Model::Spec.shared_examples_for 'Module::Path' do
+  named_module_path_factory = "named_#{module_path_factory}"
+  unnamed_module_path_factory = "un#{named_module_path_factory}"
+
+  it { should be_a ActiveModel::Dirty }
+
+  it_should_behave_like 'Metasploit::Model::RealPathname' do
+    let(:base_instance) do
+      FactoryGirl.build(module_path_factory)
+    end
+  end
+
+  context 'callbacks' do
+    context 'before_validation' do
+      context 'nilify blanks' do
+        let(:path) do
+          FactoryGirl.build(
+              module_path_factory,
+              :gem => '',
+              :name => ''
+          )
+        end
+
+        it 'should have empty gem' do
+          path.gem.should_not be_nil
+          path.gem.should be_empty
+        end
+
+        it 'should have empty name' do
+          path.name.should_not be_nil
+          path.name.should be_empty
+        end
+
+        context 'after validation' do
+          before(:each) do
+            path.valid?
+          end
+
+          its(:gem) { should be_nil }
+          its(:name) { should be_nil }
+        end
+      end
+
+      context '#normalize_real_path' do
+        let(:parent_pathname) do
+          Metasploit::Model::Spec.temporary_pathname.join('metasploit', 'model', 'module', 'path')
+        end
+
+        let(:path) do
+          FactoryGirl.build(
+              module_path_factory,
+              :real_path => symlink_pathname.to_path
+          )
+        end
+
+        let(:real_basename) do
+          'real'
+        end
+
+        let(:real_pathname) do
+          parent_pathname.join(real_basename)
+        end
+
+        let(:symlink_basename) do
+          'symlink'
+        end
+
+        let(:symlink_pathname) do
+          parent_pathname.join(symlink_basename)
+        end
+
+        before(:each) do
+          real_pathname.mkpath
+
+          Dir.chdir(parent_pathname.to_path) do
+            File.symlink(real_basename, 'symlink')
+          end
+        end
+
+        it 'should convert real_path to a real path using File#real_path' do
+          expected_real_path = Metasploit::Model::File.realpath(path.real_path)
+
+          path.real_path.should_not == expected_real_path
+
+          path.valid?
+
+          path.real_path.should == expected_real_path
+        end
+      end
+    end
+  end
+
+  context 'factories' do
+    context module_path_factory do
+      subject(module_path_factory) do
+        FactoryGirl.build(module_path_factory)
+      end
+
+      it { should be_valid }
+    end
+
+    context named_module_path_factory do
+      subject(named_module_path_factory) do
+        FactoryGirl.build(named_module_path_factory)
+      end
+
+      it { should be_valid }
+
+      its(:gem) { should_not be_nil }
+      its(:name) { should_not be_nil }
+    end
+
+    context unnamed_module_path_factory do
+      subject(unnamed_module_path_factory) do
+        FactoryGirl.build(unnamed_module_path_factory)
+      end
+
+      it { should be_valid }
+
+      its(:gem) { should be_nil }
+      its(:name) { should be_nil }
+    end
+  end
+
+  context 'mass assignment security' do
+    it { should allow_mass_assignment_of(:gem) }
+    it { should allow_mass_assignment_of(:name) }
+    it { should allow_mass_assignment_of(:real_path) }
+  end
+
+  context 'validations' do
+    context 'directory' do
+      let(:error) do
+        'must be a directory'
+      end
+
+      let(:path) do
+        FactoryGirl.build(
+            module_path_factory,
+            :real_path => real_path
+        )
+      end
+
+      before(:each) do
+        path.valid?
+      end
+
+      context 'with #real_path' do
+        context 'with directory' do
+          let(:real_path) do
+            FactoryGirl.generate :metasploit_model_module_path_directory_real_path
+          end
+
+          it 'should not record error on real_path' do
+            path.valid?
+
+            path.errors[:real_path].should_not include(error)
+          end
+        end
+
+        context 'with file' do
+          let(:pathname) do
+            Metasploit::Model::Spec.temporary_pathname.join(
+                'metasploit',
+                'model',
+                'module',
+                'path',
+                'real',
+                'path',
+                'file'
+            )
+          end
+
+          let(:real_path) do
+            pathname.to_path
+          end
+
+          before(:each) do
+            Metasploit::Model::Spec::PathnameCollision.check!(pathname)
+
+            pathname.parent.mkpath
+
+            pathname.open('wb') do |f|
+              f.puts 'A file'
+            end
+          end
+
+          it 'should record error on real_path' do
+            path.valid?
+
+            path.errors[:real_path].should include(error)
+          end
+        end
+      end
+
+      context 'without #real_path' do
+        let(:real_path) do
+          nil
+        end
+
+        it 'should record error on real_path' do
+          path.valid?
+
+          path.errors[:real_path].should include(error)
+        end
+      end
+    end
+
+    context 'gem and name' do
+      let(:gem_error) do
+        "can't be blank if name is present"
+      end
+
+      let(:name_error) do
+        "can't be blank if gem is present"
+      end
+
+      subject(:path) do
+        FactoryGirl.build(
+            module_path_factory,
+            :gem => gem,
+            :name => name
+        )
+      end
+
+      before(:each) do
+        path.valid?
+      end
+
+      context 'with gem' do
+        let(:gem) do
+          FactoryGirl.generate :metasploit_model_module_path_gem
+        end
+
+        context 'with name' do
+          let(:name) do
+            FactoryGirl.generate :metasploit_model_module_path_name
+          end
+
+          it 'should not record error on gem' do
+            path.errors[:gem].should_not include(gem_error)
+          end
+
+          it 'should not record error on name' do
+            path.errors[:name].should_not include(name_error)
+          end
+        end
+
+        context 'without name' do
+          let(:name) do
+            nil
+          end
+
+          it 'should not record error on gem' do
+            path.errors[:gem].should_not include(gem_error)
+          end
+
+          it 'should record error on name' do
+            path.errors[:name].should include(name_error)
+          end
+        end
+      end
+
+      context 'without gem' do
+        let(:gem) do
+          nil
+        end
+
+        context 'with name' do
+          let(:name) do
+            FactoryGirl.generate :metasploit_model_module_path_name
+          end
+
+          it 'should record error on gem' do
+            path.errors[:gem].should include(gem_error)
+          end
+
+          it 'should not record error on name' do
+            path.errors[:name].should_not include(name_error)
+          end
+        end
+
+        context 'without name' do
+          let(:name) do
+            nil
+          end
+
+          it 'should not record error on gem' do
+            path.errors[:gem].should_not include(gem_error)
+          end
+
+          it 'should not record error on name' do
+            path.errors[:name].should_not include(name_error)
+          end
+        end
+      end
+    end
+  end
+
+  context '#directory?' do
+    subject(:directory?) do
+      path.directory?
+    end
+
+    let(:path) do
+      FactoryGirl.build(
+          module_path_factory,
+          :real_path => real_path
+      )
+    end
+
+    context 'with #real_path' do
+      context 'with file' do
+        let(:pathname) do
+          Metasploit::Model::Spec.temporary_pathname.join(
+              'metasploit',
+              'model',
+              'module',
+              'path',
+              'real',
+              'path',
+              'file'
+          )
+        end
+
+        let(:real_path) do
+          pathname.to_path
+        end
+
+        before(:each) do
+          Metasploit::Model::Spec::PathnameCollision.check!(pathname)
+
+          pathname.parent.mkpath
+
+          pathname.open('wb') do |f|
+            f.puts 'A file'
+          end
+        end
+
+
+        it { should be_false }
+      end
+
+      context 'with directory' do
+        let(:real_path) do
+          FactoryGirl.generate :metasploit_model_module_path_directory_real_path
+        end
+
+        it { should be_true }
+      end
+    end
+
+    context 'without #real_path' do
+      let(:real_path) do
+        nil
+      end
+
+      it { should be_false }
+    end
+  end
+
+  context '#named?' do
+    subject(:named?) do
+      path.named?
+    end
+
+    let(:path) do
+      FactoryGirl.build(
+          module_path_factory,
+          :gem => gem,
+          :name => name
+      )
+    end
+
+    context 'with blank gem' do
+      let(:gem) do
+        ''
+      end
+
+      context 'with blank name' do
+        let(:name) do
+          ''
+        end
+
+        it { should be_false }
+      end
+
+      context 'without blank name' do
+        let(:name) do
+          FactoryGirl.generate :metasploit_model_module_path_name
+        end
+
+        it { should be_false }
+      end
+    end
+
+    context 'without blank gem' do
+      let(:gem) do
+        FactoryGirl.generate :metasploit_model_module_path_gem
+      end
+
+      context 'with blank name' do
+        let(:name) do
+          ''
+        end
+
+        it { should be_false }
+      end
+
+      context 'without blank name' do
+        let(:name) do
+          FactoryGirl.generate :metasploit_model_module_path_name
+        end
+
+        it { should be_true }
+      end
+    end
+  end
+
+  context '#was_named?' do
+    subject(:was_named?) do
+      path.was_named?
+    end
+
+    let(:gem) do
+      FactoryGirl.generate :metasploit_model_module_path_gem
+    end
+
+    let(:name) do
+      FactoryGirl.generate :metasploit_model_module_path_name
+    end
+
+    let(:path) do
+      FactoryGirl.build(
+          module_path_factory
+      )
+    end
+
+    before(:each) do
+      path.gem = gem_was
+      path.name = name_was
+
+      path.changed_attributes.clear
+
+      path.gem = gem
+      path.name = name
+    end
+
+    context 'with blank gem_was' do
+      let(:gem_was) do
+        nil
+      end
+
+      context 'with blank name_was' do
+        let(:name_was) do
+          nil
+        end
+
+        it { should be_false }
+      end
+
+      context 'without blank name_was' do
+        let(:name_was) do
+          FactoryGirl.generate :metasploit_model_module_path_name
+        end
+
+        it { should be_false }
+      end
+    end
+
+    context 'without blank gem_was' do
+      let(:gem_was) do
+        FactoryGirl.generate :metasploit_model_module_path_gem
+      end
+
+      context 'with blank name_was' do
+        let(:name_was) do
+          nil
+        end
+
+        it { should be_false }
+      end
+
+      context 'without blank name_was' do
+        let(:name_was) do
+          FactoryGirl.generate :metasploit_model_module_path_name
+        end
+
+        it { should be_true }
+      end
+    end
+  end
+end