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

data/spec/app/models/metasploit/model/module/ancestor/spec/template_spec.rb

@@ -0,0 +1,174 @@
+require 'spec_helper'
+
+describe Metasploit::Model::Module::Ancestor::Spec::Template do
+  subject(:template) do
+    described_class.new(
+        module_ancestor: module_ancestor
+    )
+  end
+
+  let(:module_ancestor) do
+    FactoryGirl.build(:dummy_module_ancestor)
+  end
+
+  context 'CONSTANTS' do
+    context 'DEFAULT_SEARCH_PATHNAMES' do
+      subject(:default_search_pathnames) do
+        described_class::DEFAULT_SEARCH_PATHNAMES
+      end
+
+      it "includes 'module/ancestors'" do
+        expect(default_search_pathnames).to include(Pathname.new('module/ancestors'))
+      end
+    end
+
+    context 'DEFAULT_SOURCE_RELATIVE_NAME' do
+      subject(:default_source_relative_name) do
+        described_class::DEFAULT_SOURCE_RELATIVE_NAME
+      end
+
+      it { should == 'base' }
+    end
+  end
+
+  context 'validations' do
+    it { should validate_presence_of :module_ancestor }
+  end
+
+  context '#destination_pathname' do
+    subject(:destination_pathname) do
+      template.destination_pathname
+    end
+
+    context 'with #module_ancestor' do
+      it 'defaults to module_ancestor.real_pathname' do
+        expect(destination_pathname).to eq(module_ancestor.real_pathname)
+      end
+    end
+
+    context 'without #module_ancestor' do
+      let(:module_ancestor) do
+        nil
+      end
+
+      it { should be_nil }
+    end
+  end
+
+  context '#locals' do
+    subject(:locals) do
+      template.locals
+    end
+
+    it { should be_a Hash }
+
+    context '[:metasploit_module_relative_name]' do
+      subject(:metasploit_module_relative_name) do
+        locals[:metasploit_module_relative_name]
+      end
+
+      it 'is #metasploit_module_relative_name' do
+        expect(metasploit_module_relative_name).to eq(template.metasploit_module_relative_name)
+      end
+    end
+
+    context '[:module_ancestor]' do
+      subject(:locals_module_ancestor) do
+        locals[:module_ancestor]
+      end
+
+      it 'is #module_ancestor' do
+        expect(locals_module_ancestor).to eq(template.module_ancestor)
+      end
+    end
+  end
+
+  context '#metapsloit_module_relative_name' do
+    subject(:metasploit_module_relative_name) do
+      template.metasploit_module_relative_name
+    end
+
+    it { should be_a String }
+
+    it 'uses FactoryGirl.generate' do
+      # ensure template is memoized so only metasploit_module_relative_name's usage of FactoryGirl is seen
+      template
+
+      expect(FactoryGirl).to receive(:generate).with(:metasploit_model_module_ancestor_metasploit_module_relative_name).and_call_original
+
+      metasploit_module_relative_name
+    end
+  end
+
+  context '#overwrite' do
+    subject(:overwrite) do
+      template.overwrite
+    end
+
+    it { should be_false }
+  end
+
+  context '#search_pathnames' do
+    subject(:search_pathnames) do
+      template.search_pathnames
+    end
+
+    it 'uses DEFAULT_SEARCH_PATHNAMES' do
+      expect(search_pathnames).to match_array(described_class::DEFAULT_SEARCH_PATHNAMES)
+    end
+  end
+
+  context '#source_relative_name' do
+    subject(:source_relative_name) do
+      template.source_relative_name
+    end
+
+    it 'uses DEFAULT_SOURCE_RELATIVE_NAME' do
+      expect(source_relative_name).to eq(described_class::DEFAULT_SOURCE_RELATIVE_NAME)
+    end
+  end
+
+  context 'write' do
+    subject(:write) do
+      described_class.write(attributes)
+    end
+
+    before(:each) do
+      # Since overwrite is false, have to delete the template that the factories make.
+      module_ancestor.real_pathname.delete
+    end
+
+    context 'with valid' do
+      let(:attributes) do
+        {
+            module_ancestor: module_ancestor
+        }
+      end
+
+      it { should be_true }
+
+      it 'writes template' do
+        # memoize attributes so any other writes besides the one under-test are already run.
+        attributes
+
+        described_class.any_instance.should_receive(:write)
+
+        write
+      end
+    end
+
+    context 'without valid' do
+      let(:attributes) do
+        {}
+      end
+
+      it { should be_false }
+
+      it 'does not write template' do
+        described_class.any_instance.should_not_receive(:write)
+
+        write
+      end
+    end
+  end
+end

data/spec/app/models/metasploit/model/module/class/spec/template_spec.rb

@@ -0,0 +1,222 @@
+require 'spec_helper'
+
+describe Metasploit::Model::Module::Class::Spec::Template do
+  subject(:template) do
+    described_class.new(
+        module_class: module_class
+    )
+  end
+
+  let(:module_class) do
+    FactoryGirl.build(
+        :dummy_module_class
+    )
+  end
+
+  context 'validations' do
+    it { should validate_presence_of :module_class }
+
+    context '#ancestor_templates_valid' do
+      subject(:ancestor_templates_valid) do
+        template.send(:ancestor_templates_valid)
+      end
+
+      #
+      # let
+      #
+
+      let(:error) do
+        I18n.translate!(:'errors.messages.invalid')
+      end
+
+      #
+      # Callbacks
+      #
+
+      before(:each) do
+        allow(template).to receive(:ancestor_templates).and_return(ancestor_templates)
+      end
+
+      context 'with ancestor_templates' do
+        #
+        # lets
+        #
+
+        let(:ancestor_templates) do
+          Array.new(2) { |i|
+            double("Ancestor Template #{i}")
+          }
+        end
+
+        #
+        # Callbacks
+        #
+
+        context 'with all valid' do
+          before(:each) do
+            ancestor_templates.each do |child|
+              child.stub(valid?: true)
+            end
+          end
+
+          it 'does not add error on :ancestor_templates' do
+            template.valid?
+
+            template.errors[:ancestor_templates].should_not include(error)
+          end
+        end
+
+        context 'with later valid' do
+          before(:each) do
+            ancestor_templates.first.stub(valid?: false)
+            ancestor_templates.second.stub(valid?: true)
+          end
+
+          it 'does not short-circuit and validates all ancestor_templates' do
+            ancestor_templates.second.should_receive(:valid?).and_return(true)
+
+            ancestor_templates_valid
+          end
+
+          it 'should add error on :ancestor_templates' do
+            template.valid?
+
+            template.errors[:ancestor_templates].should include(error)
+          end
+        end
+      end
+
+      context 'without ancestor_templates' do
+        let(:ancestor_templates) do
+          []
+        end
+
+        it 'does not add error on :ancestor_templates' do
+          template.valid?
+
+          template.errors[:ancestor_templates].should_not include(error)
+        end
+      end
+    end
+  end
+
+  context '#ancestor_templates' do
+    subject(:ancestor_templates) do
+      template.ancestor_templates
+    end
+
+    it 'creates Metasploit::Model::Module::Ancestor::Spec::Template for each ancestor in module_class.ancestors' do
+      template_module_ancestors = ancestor_templates.map(&:module_ancestor)
+
+      expect(template_module_ancestors).to match_array(module_class.ancestors)
+    end
+
+    context 'Metasploit::Model::Module::Ancestor::Spec::Template' do
+      context 'locals' do
+        subject(:ancestor_template_locals) do
+          ancestor_templates.map(&:locals)
+        end
+
+        context '[:module_class]' do
+          subject(:local_module_classes) do
+            ancestor_template_locals.collect { |locals|
+              locals[:module_class]
+            }
+          end
+
+          it 'is #module_class' do
+            expect(
+                local_module_classes.all? { |local_module_class|
+                  local_module_class == module_class
+                }
+            ).to be_true
+          end
+        end
+      end
+
+      context 'overwrite' do
+        subject(:overwrites) do
+          ancestor_templates.map(&:overwrite)
+        end
+
+        it 'is true so the the ancestor written templates will be overwritten by the class templates' do
+          expect(
+              overwrites.all? { |overwrite|
+                overwrite == true
+              }
+          ).to be_true
+        end
+      end
+
+      context 'search_pathnames' do
+        subject(:search_pathnames) do
+          ancestor_templates.map(&:search_pathnames)
+        end
+
+        it "has 'module/classes' before 'module/ancestors'" do
+          expect(
+              search_pathnames.all? { |template_search_pathnames|
+                module_classes_index = template_search_pathnames.index(Pathname.new('module/classes'))
+                module_ancestors_index = template_search_pathnames.index(Pathname.new('module/ancestors'))
+
+                module_classes_index < module_ancestors_index
+              }
+          ).to be_true
+        end
+      end
+    end
+  end
+
+  context 'write' do
+    subject(:write) do
+      described_class.write(attributes)
+    end
+
+    context 'with valid' do
+      let(:attributes) do
+        {
+            module_class: module_class
+        }
+      end
+
+      it { should be_true }
+
+      it 'writes template' do
+        # memoize attributes so any other writes besides the one under-test are already run.
+        attributes
+
+        described_class.any_instance.should_receive(:write)
+
+        write
+      end
+    end
+
+    context 'without valid' do
+      let(:attributes) do
+        {}
+      end
+
+      it { should be_false }
+
+      it 'does not write template' do
+        described_class.any_instance.should_not_receive(:write)
+
+        write
+      end
+    end
+  end
+
+  context '#write' do
+    subject(:write) do
+      template.write
+    end
+
+    it 'writes each ancestor template' do
+      template.ancestor_templates.each do |ancestor_template|
+        expect(ancestor_template).to receive(:write)
+      end
+
+      write
+    end
+  end
+end

data/spec/app/models/metasploit/model/module/instance/spec/template_spec.rb

@@ -0,0 +1,201 @@
+require 'spec_helper'
+
+describe Metasploit::Model::Module::Instance::Spec::Template do
+  subject(:template) do
+    described_class.new(
+        module_instance: module_instance
+    )
+  end
+
+  let(:module_instance) do
+    FactoryGirl.build(:dummy_module_instance)
+  end
+
+  context 'validations' do
+    context '#class_template' do
+      subject(:class_template_errors) do
+        template.errors[:class_template]
+      end
+
+      context 'presence' do
+        let(:error) do
+          I18n.translate!('errors.messages.blank')
+        end
+
+        context 'with nil' do
+          before(:each) do
+            allow(template).to receive(:class_template).and_return(nil)
+            template.valid?
+          end
+
+          it { should include error }
+        end
+
+        context 'without nil' do
+          before(:each) do
+            template.valid?
+          end
+
+          it { should_not include error }
+        end
+      end
+
+      context '#class_template_valid' do
+        let(:error) do
+          I18n.translate!('errors.messages.invalid')
+        end
+
+        context 'with #class_template' do
+          context 'with valid' do
+            before(:each) do
+              template.valid?
+            end
+
+            it { should_not include(error) }
+          end
+
+          context 'without valid' do
+            before(:each) do
+              expect(template.class_template).to receive(:valid?).and_return(false)
+              template.valid?
+            end
+
+            it { should include(error) }
+          end
+        end
+
+        context 'without #class_template' do
+          before(:each) do
+            allow(template).to receive(:class_template).and_return(nil)
+            template.valid?
+          end
+
+          it { should_not include(error) }
+        end
+      end
+    end
+
+    it { should validate_presence_of :module_instance }
+  end
+
+  context '#class_template' do
+    subject(:class_template) do
+      template.class_template
+    end
+
+    context 'with #module_instance' do
+      it { should be_a Metasploit::Model::Module::Class::Spec::Template }
+
+      context '#ancestor_templates' do
+        subject(:ancestor_templates) do
+          class_template.ancestor_templates
+        end
+
+        context 'locals' do
+          subject(:ancestor_template_locals) do
+            ancestor_templates.map(&:locals)
+          end
+
+          context '[:module_instance]' do
+            subject(:module_instances) do
+              ancestor_template_locals.collect { |locals|
+                locals[:module_instance]
+              }
+            end
+
+            it 'is #module_instance' do
+              expect(
+                  module_instances.all? { |actual_module_instance|
+                    actual_module_instance == module_instance
+                  }
+              ).to be_true
+            end
+          end
+        end
+
+        context 'search_pathnames' do
+          subject(:search_pathnames) do
+            ancestor_templates.map(&:search_pathnames)
+          end
+
+          it "has 'module/instances', then 'module/classes', then 'module/ancestors'" do
+            search_pathnames.each do |actual_search_pathnames|
+              module_instances_index = actual_search_pathnames.index(Pathname.new('module/instances'))
+              module_classes_index = actual_search_pathnames.index(Pathname.new('module/classes'))
+              module_ancestors_index = actual_search_pathnames.index(Pathname.new('module/ancestors'))
+
+              expect(module_instances_index).to be < module_classes_index
+              expect(module_classes_index).to be < module_ancestors_index
+            end
+          end
+        end
+      end
+
+      context '#module_class' do
+        it 'is module_instance.module_class' do
+          expect(class_template.module_class).to eq(module_instance.module_class)
+        end
+      end
+    end
+
+    context 'without #module_instance' do
+      let(:module_instance) do
+        nil
+      end
+
+      it { should be_nil }
+    end
+  end
+
+  context 'write' do
+    subject(:write) do
+      described_class.write(attributes)
+    end
+
+    context 'with valid' do
+      let(:attributes) do
+        {
+            module_instance: module_instance
+        }
+      end
+
+      it { should be_true }
+
+      it 'writes template' do
+        # memoize attributes so any other writes besides the one under-test are already run.
+        attributes
+
+        described_class.any_instance.should_receive(:write)
+
+        write
+      end
+    end
+
+    context 'without valid' do
+      let(:attributes) do
+        {}
+      end
+
+      it { should be_false }
+
+      it 'does not write template' do
+        described_class.any_instance.should_not_receive(:write)
+
+        write
+      end
+    end
+  end
+
+  context '#write' do
+    subject(:write) do
+      template.write
+    end
+
+    it 'delegates to #class_template' do
+      expected = double('#write')
+
+      expect(template.class_template).to receive(:write).and_return(expected)
+      expect(write).to eq(expected)
+    end
+  end
+end