metasploit-model 0.28.0 → 0.29.0

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

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

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

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

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