metasploit-erd 0.0.1

data/spec/metasploit/erd/diagram_spec.rb

@@ -0,0 +1,238 @@
+require 'spec_helper'
+
+describe Metasploit::ERD::Diagram do
+  subject(:diagram) {
+    described_class.new(*arguments)
+  }
+
+  let(:arguments) {
+    [
+        domain
+    ]
+  }
+
+  let(:domain) {
+    RailsERD::Domain.new
+  }
+
+  it { should be_a RailsERD::Diagram::Graphviz }
+
+  context 'CONSTANTS' do
+    context 'ATTRIBUTES' do
+      subject(:attributes) {
+        described_class::ATTRIBUTES
+      }
+
+      it { should include :content }
+      it { should include :foreign_keys }
+      it { should include :primary_keys }
+      it { should include :timestamps }
+    end
+
+    context 'DEFAULT_OPTIONS' do
+      subject(:default_options) {
+        described_class::DEFAULT_OPTIONS
+      }
+
+      context '[:attributes]' do
+        subject(:attributes) {
+          default_options[:attributes]
+        }
+
+        it 'should be ATTRIBUTES' do
+          expect(attributes).to eq(described_class::ATTRIBUTES)
+        end
+      end
+
+      context '[:filetype]' do
+        subject(:filetype) {
+          default_options[:filetype]
+        }
+
+        it 'should be FILETYPE' do
+          expect(filetype).to eq(described_class::FILETYPE)
+        end
+      end
+
+      context '[:indirect]' do
+        subject(:indirect) {
+          default_options[:indirect]
+        }
+
+        it 'should be INDIRECT' do
+          expect(indirect).to eq(described_class::INDIRECT)
+        end
+      end
+
+      context '[:inheritance]' do
+        subject(:inheritance) {
+          default_options[:inheritance]
+        }
+
+        it 'should be INHERITANCE' do
+          expect(inheritance).to eq(described_class::INHERITANCE)
+        end
+      end
+
+      context '[:notation]' do
+        subject(:notation) {
+          default_options[:notation]
+        }
+
+        it 'should be NOTATION' do
+          expect(notation).to eq(described_class::NOTATION)
+        end
+      end
+
+      context '[:polymorphism]' do
+        subject(:polymorphism) {
+          default_options[:polymorphism]
+        }
+
+        it 'should be POLYMORPHISM' do
+          expect(polymorphism).to eq(described_class::POLYMORPHISM)
+        end
+      end
+    end
+
+    context 'FILETYPE' do
+      subject(:filetype) {
+        described_class::FILETYPE
+      }
+
+      it { should == :png }
+    end
+
+    context 'INDIRECT' do
+      subject(:indirect) {
+        described_class::INDIRECT
+      }
+
+      it { should be_false }
+    end
+
+    context 'INHERITANCE' do
+      subject(:inheritance)  {
+        described_class::INHERITANCE
+      }
+
+      it { should be_true }
+    end
+
+    context 'NOTATION' do
+      subject(:notation) {
+        described_class::NOTATION
+      }
+
+      it { should == :crowsfoot }
+    end
+
+    context 'POLYMORPHISM' do
+      subject(:polymorphism) {
+        described_class::POLYMORPHISM
+      }
+
+      it { should be_true }
+    end
+  end
+
+  context 'callbacks' do
+    subject(:callbacks) {
+      described_class.send(:callbacks)
+    }
+
+    context '[:each_entity]' do
+      subject(:each_entity) {
+        callbacks[:each_entity]
+      }
+
+      it { should_not be_nil }
+
+      it 'uses RailsERD::Diagram::Graphviz.callbacks[:each_entity]' do
+        expect(each_entity).to eq(RailsERD::Diagram::Graphviz.send(:callbacks)[:each_entity])
+      end
+    end
+
+    context '[:each_relationship]' do
+      subject(:each_relationship) {
+        callbacks[:each_relationship]
+      }
+
+      it { should_not be_nil }
+
+      it 'uses RailsERD::Diagram::Graphviz.callbacks[:each_relationship]' do
+        expect(each_relationship).to eq(RailsERD::Diagram::Graphviz.send(:callbacks)[:each_relationship])
+      end
+    end
+
+    context '[:each_specialization]' do
+      subject(:each_specialization) {
+        callbacks[:each_specialization]
+      }
+
+      it { should_not be_nil }
+
+      it 'uses RailsERD::Diagram::Graphviz.callbacks[:each_specialization]' do
+        expect(each_specialization).to eq(RailsERD::Diagram::Graphviz.send(:callbacks)[:each_specialization])
+      end
+    end
+
+    context '[:save]' do
+      subject(:save) {
+        callbacks[:save]
+      }
+
+      it { should_not be_nil }
+
+      it 'extends RailsERD::Diagram::Graphviz.callbacks[:save]' do
+        expect(save).not_to eq(RailsERD::Diagram::Graphviz.send(:callbacks)[:save])
+      end
+    end
+
+    context '[:setup]' do
+      subject(:setup) {
+        callbacks[:setup]
+      }
+
+      it { should_not be_nil }
+
+      it 'uses RailsERD::Diagram::Graphviz.callbacks[:setup]' do
+        expect(setup).to eq(RailsERD::Diagram::Graphviz.send(:callbacks)[:setup])
+      end
+    end
+  end
+
+  context '#initialize' do
+    context 'with domain' do
+      it 'uses first argument as domain' do
+        expect(diagram.domain).to eq(arguments.first)
+      end
+
+      context 'with options' do
+        let(:arguments) {
+          super() + [options]
+        }
+
+        let(:options) {
+          {
+              key: :value
+          }
+        }
+
+        it 'merges options with DEFAULT_OPTIONS' do
+          expect(described_class::DEFAULT_OPTIONS).to receive(:merge).with(options).and_call_original
+
+          diagram
+        end
+      end
+
+      context 'without options' do
+        it 'uses DEFAULT_OPTIONS as #options' do
+          described_class::DEFAULT_OPTIONS.each do |key, value|
+            expect(diagram.options[key]).to eq(value)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,236 @@
+require 'spec_helper'
+
+describe Metasploit::ERD::Entity::Class do
+  include_context 'ActiveRecord::Base.descendants cleaner'
+
+  subject(:class_entity) {
+    described_class.new(klass)
+  }
+
+  #
+  # lets
+  #
+
+  let(:klass) {
+    Class.new(ActiveRecord::Base)
+  }
+
+  let(:klass_name) do
+    'Klass'
+  end
+
+  #
+  # Callbacks
+  #
+
+  before(:each) do
+    stub_const(klass_name, klass)
+  end
+
+  it_should_behave_like 'Metasploit::ERD::Clusterable' do
+    let(:entity) {
+      described_class.new(Dummy::Widget)
+    }
+  end
+
+  context '#class_set' do
+    include_context 'ActiveRecord::Base connection'
+
+    subject(:class_set) do
+      class_entity.class_set
+    end
+
+    context 'with belongs_to associations' do
+      context 'with same class twice' do
+        #
+        # lets
+        #
+
+        let(:target_name) do
+          'Target'
+        end
+
+        let(:target) do
+          Class.new(ActiveRecord::Base)
+        end
+
+        #
+        # Callbacks
+        #
+
+        before(:each) do
+          target_name = self.target_name
+
+          stub_const(target_name, target)
+
+          klass.class_eval do
+            #
+            # Associations
+            #
+
+            # @!attribute first_target
+            #   @return [Target]
+            belongs_to :first_target,
+                       class_name: target_name,
+                       inverse_of: :first_klasses
+
+            # @!attribute second_target
+            #   @return [Target]
+            belongs_to :second_target,
+                       class_name: target_name,
+                       inverse_of: :second_klasses
+          end
+
+          klass_name = self.klass_name
+
+          target.class_eval do
+            #
+            # Associations
+            #
+
+            # @!attribute first_klasses
+            #   @return [ActiveRecord::Relation<Klass>]
+            has_many :first_klasses,
+                     class_name: klass_name,
+                     inverse_of: :first_target
+
+            # @!attribute second_klasses
+            #   @return [ActiveRecord::Relation<Klass>]
+            has_many :second_klasses,
+                     class_name: klass_name,
+                     inverse_of: :second_target
+          end
+
+          ActiveRecord::Migration.verbose = false
+
+          ActiveRecord::Migration.create_table :targets do |t|
+            t.timestamps
+          end
+
+          ActiveRecord::Migration.create_table :klasses do |t|
+            t.references :first_target
+            t.references :second_target
+
+            t.timestamps
+          end
+        end
+
+        it 'includes class once' do
+          expect(class_set).to have(1).items
+          expect(class_set).to include(target)
+        end
+      end
+
+      context 'with has_many associations' do
+        let(:belongs_to_target) do
+          Class.new(ActiveRecord::Base)
+        end
+
+        let(:belongs_to_target_name) do
+          'BelongsToTarget'
+        end
+
+        let(:has_many_target) do
+          Class.new(ActiveRecord::Base)
+        end
+
+        let(:has_many_target_name) do
+          'HasManyTarget'
+        end
+
+        before(:each) do
+          belongs_to_target_name = self.belongs_to_target_name
+          klass_name = self.klass_name
+          has_many_target_name = self.has_many_target_name
+
+          stub_const(belongs_to_target_name, belongs_to_target)
+          stub_const(has_many_target_name, has_many_target)
+
+          belongs_to_target.class_eval do
+            #
+            # Associations
+            #
+
+            # @!attribute klasses
+            #   @return [ActiveRecord::Relation<Klass>]
+            has_many :klasses,
+                     class_name: klass_name,
+                     inverse_of: :belongs_to_target
+          end
+
+          has_many_target.class_eval do
+            #
+            # Associations
+            #
+
+            # @!attribute klass
+            #   @return [Klass]
+            belongs_to :klass,
+                       class_name: klass_name,
+                       inverse_of: :has_many_targets
+          end
+
+          klass.class_eval do
+            #
+            # Associations
+            #
+
+            # @!attribute belongs_to_target
+            #   @return [BelongsToTarget]
+            belongs_to :belongs_to_target,
+                       class_name: belongs_to_target_name,
+                       inverse_of: :klasses
+
+            # @!attribute has_many_targets
+            #   @return [HasManyTarget]
+            has_many :has_many_target,
+                     class_name: has_many_target_name,
+                     inverse_of: :klass
+          end
+
+          ActiveRecord::Migration.verbose = false
+
+          ActiveRecord::Migration.create_table :belongs_to_targets do |t|
+            t.timestamps
+          end
+
+          ActiveRecord::Migration.create_table :klass do |t|
+            t.references :belongs_to_target
+
+            t.timestamps
+          end
+
+          ActiveRecord::Migration.create_table :has_many_targets do |t|
+            t.references :klass
+
+            t.timestamps
+          end
+        end
+
+        it 'includes belongs_to target classes' do
+          expect(class_set).to include(belongs_to_target)
+        end
+
+        it 'does not include has_many target classes' do
+          expect(class_set).not_to include(has_many_target)
+        end
+      end
+    end
+
+    context 'without belongs_to associations' do
+      it { should be_empty }
+    end
+  end
+
+  context '#cluster' do
+    subject(:cluster) {
+      class_entity.cluster
+    }
+
+    it 'creates a Metasploit::ERD::Cluster containing #klass' do
+      expect(Metasploit::ERD::Cluster).to receive(:new).with(klass)
+
+      cluster
+    end
+  end
+end