metasploit-erd 0.0.1

data/spec/metasploit/erd/entity/namespace_spec.rb

@@ -0,0 +1,130 @@
+require 'spec_helper'
+
+describe Metasploit::ERD::Entity::Namespace do
+  include_context 'ActiveRecord::Base.descendants cleaner'
+
+  subject(:namespace_entity) {
+    described_class.new(namespace_name)
+  }
+
+  let(:namespace_name) {
+    'Namespace'
+  }
+
+  it_should_behave_like 'Metasploit::ERD::Clusterable' do
+    let(:entity) {
+      described_class.new('Dummy')
+    }
+  end
+
+  context '#classes' do
+    subject(:namespace_entities) {
+      namespace_entity.classes
+    }
+
+    #
+    # lets
+    #
+
+    let(:other_namespace_name) {
+      'OtherNamespace'
+    }
+
+    #
+    # Callbacks
+    #
+
+    before(:each) do
+      stub_const(other_namespace_name, Module.new)
+      stub_const(namespace_name, Module.new)
+    end
+
+    context 'with ActiveRecord::Base descendants' do
+      let(:child_name) {
+        'Child'
+      }
+
+      let(:childnamespace_name) {
+        'ChildNamespace'
+      }
+
+      let(:grandchild_name) do
+        'GrandChild'
+      end
+
+      let(:other_namespaced_child_name) {
+        "#{other_namespace_name}::#{child_name}"
+      }
+
+      let(:other_namespaced_child) {
+        other_namespaced_child_name.constantize
+      }
+
+      let(:namespaced_child) do
+        namespaced_child_name.constantize
+      end
+
+      let(:namespaced_child_name) {
+        "#{namespace_name}::#{child_name}"
+      }
+
+      let(:namespaced_child_namespace_name) {
+        "#{namespace_name}::#{childnamespace_name}"
+      }
+
+      let(:namespaced_grandchild) {
+        namespaced_grandchild_name.constantize
+      }
+
+      let(:namespaced_grandchild_name) {
+        "#{namespaced_child_namespace_name}::#{grandchild_name}"
+      }
+
+      #
+      # Callbacks
+      #
+
+      before(:each) do
+        stub_const(other_namespaced_child_name, Class.new(ActiveRecord::Base))
+
+        stub_const(namespaced_child_name, Class.new(ActiveRecord::Base))
+
+        stub_const(namespaced_child_namespace_name, Module.new)
+        stub_const(namespaced_grandchild_name, Class.new(ActiveRecord::Base))
+      end
+
+      it 'does not include entities from other namespaces' do
+        expect(namespace_entities).not_to include(other_namespaced_child)
+      end
+
+      it 'includes direct children of the namespace' do
+        expect(namespace_entities).to include(namespaced_child)
+      end
+
+      it 'includes indirect descendants of the namespace' do
+        expect(namespace_entities).to include(namespaced_grandchild)
+      end
+    end
+
+    context 'without ActiveRecord::Base descendants' do
+      it { should be_empty }
+    end
+  end
+
+  context '#cluster' do
+    subject(:cluster) {
+      namespace_entity.cluster
+    }
+
+    it 'created a Metasploit::ERD::Cluster containing #classes' do
+      classes = Array.new(2) { |n|
+        double("Class#{n}")
+      }
+
+      expect(namespace_entity).to receive(:classes).and_return(classes)
+      expect(Metasploit::ERD::Cluster).to receive(:new).with(*classes)
+
+      cluster
+    end
+  end
+end

data/spec/metasploit/erd/relationship_spec.rb

@@ -0,0 +1,246 @@
+require 'spec_helper'
+
+describe Metasploit::ERD::Relationship do
+  include_context 'ActiveRecord::Base connection'
+  include_context 'ActiveRecord::Base.descendants cleaner'
+
+  subject(:relationship) {
+    described_class.new(association)
+  }
+
+  #
+  # lets
+  #
+
+  let(:owner) {
+    Class.new(ActiveRecord::Base)
+  }
+
+  let(:owner_name) {
+    'Owner'
+  }
+
+  #
+  # Callbacks
+  #
+
+  before(:each) do
+    stub_const(owner_name, owner)
+  end
+
+  context '#class_set' do
+    subject(:class_set) {
+      relationship.class_set
+    }
+
+    context 'with polymorphic:' do
+      context 'false' do
+        let(:association) {
+          owner.reflect_on_association(:klass)
+        }
+
+        let(:klass) {
+          Class.new(ActiveRecord::Base)
+        }
+
+        let(:klass_name) {
+          'Klass'
+        }
+
+        #
+        # Callbacks
+        #
+
+        before(:each) do
+          stub_const(klass_name, klass)
+
+          owner.belongs_to :klass,
+                           class_name: klass_name,
+                           inverse_of: :owneres
+
+          klass.has_many :owners,
+                         class_name: 'Owner',
+                         inverse_of: :klass
+
+          ActiveRecord::Migration.verbose = false
+
+          ActiveRecord::Migration.create_table :klasses do |t|
+            t.timestamps
+          end
+
+          ActiveRecord::Migration.create_table :owners do |t|
+            t.references :klass
+
+            t.timestamps
+          end
+        end
+
+        it { should be_a Set }
+
+        it 'includes association.klass' do
+          expect(class_set).to include(association.klass)
+        end
+      end
+
+      context 'true' do
+        #
+        # lets
+        #
+
+        let(:association) {
+          owner.reflect_on_association(:thing)
+        }
+
+        let(:things) {
+          owner_name = self.owner_name
+
+          thing_names.collect { |class_name|
+            klass = Class.new(ActiveRecord::Base) {
+              has_many :owners,
+                       as: :thing,
+                       class_name: owner_name
+            }
+
+            stub_const(class_name, klass)
+          }
+        }
+
+        let(:thing_names) {
+          Array.new(2) { |n|
+            "Thing#{n}"
+          }
+        }
+
+        #
+        # Callbacks
+        #
+
+        before(:each) do
+          owner.belongs_to :thing,
+                           polymorphic: true
+
+          # ensure polymorphic target classes are created
+          things
+
+          ActiveRecord::Migration.verbose = false
+
+          ActiveRecord::Migration.create_table :owners do |t|
+            t.references :thing
+
+            t.timestamp
+          end
+
+          things.each do |thing|
+            ActiveRecord::Migration.create_table thing.table_name do |t|
+              t.timestamp
+            end
+          end
+        end
+
+        it { should be_a Set }
+
+        it 'includes all classes that have has_many <inverse>, as: <reflection.name>' do
+          expect(class_set).to eq(Set.new(things))
+        end
+
+        it 'calls #polymorphic_class_set' do
+          expect(relationship).to receive(:polymorphic_class_set)
+
+          class_set
+        end
+      end
+    end
+  end
+
+  context '#polymorphic_class_set' do
+    subject(:polymorphic_class_set) {
+      relationship.send(:polymorphic_class_set)
+    }
+
+    #
+    # Lets
+    #
+
+    let(:association) {
+      owner.reflect_on_association(:first)
+    }
+
+    let(:group_names) {
+      [
+          'First',
+          'Second'
+      ]
+    }
+
+    let(:polymorphics_by_group_name) {
+      owner_name = self.owner_name
+
+      polymorphic_names_by_group_name.each_with_object({}) { |(group_name, polymorphic_names), hash|
+        hash[group_name] = polymorphic_names.collect { |class_name|
+          klass = Class.new(ActiveRecord::Base) {
+            has_many :owners,
+                     as: group_name.underscore.to_sym,
+                     class_name: owner_name
+          }
+
+          stub_const(class_name, klass)
+        }
+      }
+    }
+
+    let(:polymorphic_names_by_group_name) {
+      group_names.each_with_object({}) { |group_name, hash|
+        hash[group_name] = Array.new(2) { |n|
+          "#{group_name}Polymorphic#{n}"
+        }
+      }
+    }
+
+    #
+    # Callbacks
+    #
+
+    before(:each) do
+      group_names.each do |group_name|
+        owner.belongs_to group_name.underscore.to_sym,
+                         polymorphic: true
+      end
+
+      ActiveRecord::Migration.verbose = false
+
+      ActiveRecord::Migration.create_table :owners do |t|
+        group_names.each do |group_name|
+          t.references group_name.underscore.to_sym
+        end
+
+        t.timestamp
+      end
+
+      polymorphics_by_group_name.each do |group_name, polymorphics|
+        polymorphics.each do |klass|
+          ActiveRecord::Migration.create_table klass.table_name do |t|
+            t.timestamps
+          end
+        end
+      end
+    end
+
+    it { should be_a Set }
+
+    context 'with has_many as: <association.name>' do
+      it 'includes classes' do
+        polymorphics_by_group_name['First'].each do |klass|
+          expect(polymorphic_class_set).to include(klass)
+        end
+      end
+    end
+
+    context 'with has_many as: <not association.name>' do
+      it 'does not include classes' do
+        polymorphics_by_group_name['Second'].each do |klass|
+          expect(polymorphic_class_set).not_to include(klass)
+        end
+      end
+    end
+  end
+end

data/spec/metasploit/erd/version_spec.rb

@@ -0,0 +1,125 @@
+require 'spec_helper'
+
+require 'active_support/core_ext/object/blank'
+
+describe Metasploit::ERD::Version do
+  context 'CONSTANTS' do
+    context 'MAJOR' do
+      subject(:major) do
+        described_class::MAJOR
+      end
+
+      it 'is 0 because the API is not locked yet' do
+        expect(major).to eq(0)
+      end
+    end
+
+    context 'MINOR' do
+      subject(:minor) do
+        described_class::MINOR
+      end
+
+      it { should be_a Integer }
+    end
+
+    context 'PATCH' do
+      subject(:patch) do
+        described_class::PATCH
+      end
+
+      it { should be_a Integer }
+    end
+
+    pull_request = ENV['TRAVIS_PULL_REQUEST']
+
+    # a pull request cannot check PRERELEASE because it will be tested in the target branch, but the source itself
+    # is from the source branch and so has the source branch PRERELEASE.
+    #
+    # PRERELEASE can only be set appropriately for a merge by merging to the target branch and then updating PRERELEASE
+    # on the target branch before committing and/or pushing to github and travis-ci.
+    if pull_request.nil? || pull_request == 'false'
+      context 'PREPRELEASE' do
+        subject(:prerelease) do
+          described_class::PRERELEASE
+        end
+
+        branch = ENV['TRAVIS_BRANCH']
+
+        if branch.blank?
+          branch = `git rev-parse --abbrev-ref HEAD`.strip
+        end
+
+        if branch == 'master'
+          it 'does not have a PRERELEASE' do
+            expect(defined? described_class::PRERELEASE).to be_nil
+          end
+        else
+          feature_regex = /(feature|staging)\/(?<prerelease>.*)/
+          match = branch.match(feature_regex)
+
+          if match
+            it 'matches the branch relative name' do
+              expect(prerelease).to eq(match[:prerelease])
+            end
+          else
+            it 'has a abbreviated reference that can be parsed for prerelease' do
+              fail "Do not know how to parse #{branch.inspect} for PRERELEASE"
+            end
+          end
+        end
+      end
+    end
+  end
+
+  context 'full' do
+    subject(:full) do
+      described_class.full
+    end
+
+    #
+    # lets
+    #
+
+    let(:major) do
+      1
+    end
+
+    let(:minor) do
+      2
+    end
+
+    let(:patch) do
+      3
+    end
+
+    before(:each) do
+      stub_const("#{described_class}::MAJOR", major)
+      stub_const("#{described_class}::MINOR", minor)
+      stub_const("#{described_class}::PATCH", patch)
+    end
+
+    context 'with PRERELEASE' do
+      let(:prerelease) do
+        'prerelease'
+      end
+
+      before(:each) do
+        stub_const("#{described_class}::PRERELEASE", prerelease)
+      end
+
+      it 'is <major>.<minor>.<patch>-<prerelease>' do
+        expect(full).to eq("#{major}.#{minor}.#{patch}-#{prerelease}")
+      end
+    end
+
+    context 'without PRERELEASE' do
+      before(:each) do
+        hide_const("#{described_class}::PRERELEASE")
+      end
+
+      it 'is <major>.<minor>.<patch>' do
+        expect(full).to eq("#{major}.#{minor}.#{patch}")
+      end
+    end
+  end
+end