rails-erd 0.3.0 → 0.4.0

data/test/unit/domain_test.rb

@@ -23,29 +23,56 @@ class DomainTest < ActiveSupport::TestCase
     assert_nil Domain.generate.name
   end
   
-  test "inspect should display relationships" do
+  test "inspect should display object id only" do
     create_model "Foo", :bar => :references do
       belongs_to :bar
     end
     create_model "Bar"
-    assert_match %r{#<RailsERD::Domain:.* \{Bar => Foo\}>}, Domain.generate.inspect
+    assert_match %r{#<RailsERD::Domain:.*>}, Domain.generate.inspect
   end
   
   # Entity processing ========================================================
-  test "entity_for should return associated entity for given model" do
+  test "entity_by_name should return associated entity for given name" do
     create_model "Foo"
-    assert_equal Foo, Domain.generate.entity_for(Foo).model
+    assert_equal Foo, Domain.generate.entity_by_name("Foo").model
   end
   
   test "entities should return domain entities" do
     create_models "Foo", "Bar"
-    assert_equal [Entity] * 2, Domain.generate.entities.collect(&:class)
+    assert_equal [Domain::Entity] * 2, Domain.generate.entities.collect(&:class)
   end
   
   test "entities should return all domain entities sorted by name" do
     create_models "Foo", "Bar", "Baz", "Qux"
     assert_equal [Bar, Baz, Foo, Qux], Domain.generate.entities.collect(&:model)
   end
+
+  test "entities should include abstract entities" do
+    create_model "Stronghold" do
+      has_many :cannons, :as => :defensible
+    end
+    assert_equal ["Defensible", "Stronghold"], Domain.generate.entities.collect(&:name)
+  end
+
+  test "entities should include abstract entities only once" do
+    create_model "Stronghold" do
+      has_many :cannons, :as => :defensible
+    end
+    create_model "Galleon" do
+      has_many :cannons, :as => :defensible
+    end
+    assert_equal ["Defensible", "Galleon", "Stronghold"], Domain.generate.entities.collect(&:name)
+  end
+  
+  test "entities should omit abstract models" do
+    Object.const_set :Foo, Class.new(ActiveRecord::Base) { self.abstract_class = true }
+    create_model "Bar", Foo do
+      set_table_name "bars"
+    end
+    create_table "foos", {}, true
+    create_table "bars", {}, true
+    assert_equal ["Bar"], Domain.generate.entities.collect(&:name)
+  end
   
   # Relationship processing ==================================================
   test "relationships should return empty array for empty domain" do
@@ -61,7 +88,7 @@ class DomainTest < ActiveSupport::TestCase
     create_model "Bar", :baz => :references do
       belongs_to :baz
     end
-    assert_equal [Relationship] * 3, Domain.generate.relationships.collect(&:class)
+    assert_equal [Domain::Relationship] * 3, Domain.generate.relationships.collect(&:class)
   end
   
   test "relationships should count mutual relationship as one" do
@@ -71,7 +98,23 @@ class DomainTest < ActiveSupport::TestCase
     create_model "Bar" do
       has_many :foos
     end
-    assert_equal [Relationship], Domain.generate.relationships.collect(&:class)
+    assert_equal [Domain::Relationship], Domain.generate.relationships.collect(&:class)
+  end
+
+  test "relationships should count mutual indirect relationship as one" do
+    create_model "Wizard" do
+      has_many :spell_masteries
+      has_many :spells, :through => :spell_masteries
+    end
+    create_model "Spell" do
+      has_many :spell_masteries
+      has_many :wizards, :through => :spell_masteries
+    end
+    create_model "SpellMastery", :wizard => :references, :spell => :references do
+      belongs_to :wizard
+      belongs_to :spell
+    end
+    assert_equal [Domain::Relationship], Domain.generate.relationships.select(&:indirect?).collect(&:class)
   end
   
   test "relationships should count relationship between same models with distinct foreign key seperately" do
@@ -81,9 +124,62 @@ class DomainTest < ActiveSupport::TestCase
     create_model "Bar" do
       has_many :foos, :foreign_key => :special_bar_id
     end
-    assert_equal [Relationship] * 2, Domain.generate.relationships.collect(&:class)
+    assert_equal [Domain::Relationship] * 2, Domain.generate.relationships.collect(&:class)
+  end
+  
+  # Specialization processing ================================================
+  test "specializations should return empty array for empty domain" do
+    assert_equal [], Domain.generate.specializations
+  end
+
+  test "specializations should return empty array for domain without single table inheritance" do
+    create_simple_domain
+    assert_equal [], Domain.generate.specializations
+  end
+
+  test "specializations should return specializations in domain model" do
+    create_specialization
+    assert_equal [Domain::Specialization], Domain.generate.specializations.collect(&:class)
+  end
+
+  test "specializations should return specializations of specializations in domain model" do
+    create_specialization
+    Object.const_set :BelgianBeer, Class.new(Beer)
+    assert_equal [Domain::Specialization] * 2, Domain.generate.specializations.collect(&:class)
+  end
+  
+  test "specializations should return generalizations in domain model" do
+    create_model "Post" do
+      has_many :assets, :as => :attachable
+    end
+    create_model "Asset", :attachable => :references do
+      belongs_to :attachable, :polymorphic => true
+    end
+    assert_equal [Domain::Specialization], Domain.generate.specializations.collect(&:class)
+  end
+
+  test "specializations should return generalizations and specializations in domain model" do
+    create_model "Content", :type => :string do
+      has_many :assets, :as => :attachable
+    end
+    Object.const_set :Post, Class.new(Content)
+    create_model "Asset", :attachable => :references do
+      belongs_to :attachable, :polymorphic => true
+    end
+    assert_equal [Domain::Specialization] * 2, Domain.generate.specializations.collect(&:class)
   end
   
+  # test "generalizations should ..." do
+  #   # TODO
+  #   create_model "Post" do
+  #     has_many :assets, :as => :attachable
+  #   end
+  #   create_model "Asset", :attachable => :references do
+  #     belongs_to :attachable, :polymorphic => true
+  #   end
+  #   assert_equal [], Domain.generate.relationships
+  # end
+  
   # Erroneous associations ===================================================
   test "relationships should omit bad has_many associations" do
     create_model "Foo" do
@@ -128,6 +224,19 @@ class DomainTest < ActiveSupport::TestCase
     assert_match /model Bar exists, but is not included in domain/, output
   end
 
+  test "relationships should output a warning when an association to a non existent generalization is encountere" do
+    create_model "Foo" do
+      has_many :bars, :as => :foo
+    end
+    create_model "Bar", :foobar => :references do
+      belongs_to :foo_bar, :polymorphic => true
+    end
+    output = collect_stdout do
+      Domain.generate.relationships
+    end
+    assert_match /polymorphic interface FooBar does not exist/, output
+  end
+
   test "relationships should not warn when a bad association is encountered if warnings are disabled" do
     create_model "Foo" do
       has_many :flabs
@@ -137,4 +246,18 @@ class DomainTest < ActiveSupport::TestCase
     end
     assert_equal "", output
   end
+  
+  # Erroneous models =========================================================
+  test "entities should omit bad models" do
+    Object.const_set :Foo, Class.new(ActiveRecord::Base)
+    assert_equal [], Domain.generate(:warn => false).entities
+  end
+
+  test "entities should output a warning when a model table does not exist" do
+    Object.const_set :Foo, Class.new(ActiveRecord::Base)
+    output = collect_stdout do
+      Domain.generate.entities
+    end
+    assert_match /Ignoring invalid model Foo \(table foos does not exist\)/, output
+  end
 end

data/test/unit/entity_test.rb

@@ -1,31 +1,39 @@
 require File.expand_path("../test_helper", File.dirname(__FILE__))
 
 class EntityTest < ActiveSupport::TestCase
+  def create_entity(model)
+    Domain::Entity.new(Domain.new, model.name, model)
+  end
+  
+  def create_generalized_entity(name)
+    Domain::Entity.new(Domain.new, name)
+  end
+  
   # Entity ===================================================================
   test "model should return active record model" do
     create_models "Foo"
-    assert_equal Foo, Entity.new(Domain.new, Foo).model
+    assert_equal Foo, create_entity(Foo).model
   end
   
   test "name should return model name" do
     create_models "Foo"
-    assert_equal "Foo", Entity.new(Domain.new, Foo).name
+    assert_equal "Foo", create_entity(Foo).name
   end
 
   test "spaceship should sort entities by name" do
     create_models "Foo", "Bar"
-    foo, bar = Entity.new(Domain.new, Foo), Entity.new(Domain.new, Bar)
+    foo, bar = create_entity(Foo), create_entity(Bar)
     assert_equal [bar, foo], [foo, bar].sort
   end
   
   test "to_s should equal name" do
     create_models "Foo"
-    assert_equal "Foo", Entity.new(Domain.new, Foo).to_s
+    assert_equal "Foo", create_entity(Foo).to_s
   end
 
   test "inspect should show name" do
     create_models "Foo"
-    assert_match %r{#<RailsERD::Entity:.* @model=Foo>}, Entity.new(Domain.new, Foo).inspect
+    assert_match %r{#<RailsERD::Domain::Entity:.* @model=Foo>}, create_entity(Foo).inspect
   end
 
   test "relationships should return relationships for this model" do
@@ -38,7 +46,7 @@ class EntityTest < ActiveSupport::TestCase
     create_model "Baz"
 
     domain = Domain.generate
-    foo = domain.entity_for(Foo)
+    foo = domain.entity_by_name("Foo")
     assert_equal domain.relationships.select { |r| r.destination == foo }, foo.relationships
   end
   
@@ -51,39 +59,39 @@ class EntityTest < ActiveSupport::TestCase
     create_model "Baz"
 
     domain = Domain.generate
-    foo = domain.entity_for(Foo)
+    foo = domain.entity_by_name("Foo")
     assert_equal domain.relationships.select { |r| r.destination == foo }, foo.relationships
   end
 
-  test "parent should return nil for regular entities" do
-    create_model "Foo"
-    assert_nil Entity.new(Domain.new, Foo).parent
-  end
-
-  test "parent should return nil for descended models with distinct tables" do
-    create_model "Foo", :type => :string
-    Object.const_set :SpecialFoo, Class.new(Foo)
-    SpecialFoo.class_eval do
-      set_table_name "special_foo"
-    end
-    create_table "special_foo", {}, true
-    assert_nil Entity.new(Domain.new, SpecialFoo).parent
-  end
-
-  test "parent should return parent entity for child entities" do
-    create_model "Foo", :type => :string
-    Object.const_set :SpecialFoo, Class.new(Foo)
-    domain = Domain.generate
-    assert_equal domain.entity_for(Foo), Entity.new(domain, SpecialFoo).parent
-  end
-
-  test "parent should return parent entity for children of child entities" do
-    create_model "Foo", :type => :string
-    Object.const_set :SpecialFoo, Class.new(Foo)
-    Object.const_set :VerySpecialFoo, Class.new(SpecialFoo)
-    domain = Domain.generate
-    assert_equal domain.entity_for(SpecialFoo), Entity.new(domain, VerySpecialFoo).parent
-  end
+  # test "parent should return nil for regular entities" do
+  #   create_model "Foo"
+  #   assert_nil create_entity(Foo).parent
+  # end
+  # 
+  # test "parent should return nil for specialized entities with distinct tables" do
+  #   create_model "Foo", :type => :string
+  #   Object.const_set :SpecialFoo, Class.new(Foo)
+  #   SpecialFoo.class_eval do
+  #     set_table_name "special_foo"
+  #   end
+  #   create_table "special_foo", {}, true
+  #   assert_nil create_entity(SpecialFoo).parent
+  # end
+  # 
+  # test "parent should return parent entity for specialized entities" do
+  #   create_model "Foo", :type => :string
+  #   Object.const_set :SpecialFoo, Class.new(Foo)
+  #   domain = Domain.generate
+  #   assert_equal domain.entity_by_name("Foo"), Domain::Entity.from_models(domain, [SpecialFoo]).first.parent
+  # end
+  # 
+  # test "parent should return parent entity for specializations of specialized entities" do
+  #   create_model "Foo", :type => :string
+  #   Object.const_set :SpecialFoo, Class.new(Foo)
+  #   Object.const_set :VerySpecialFoo, Class.new(SpecialFoo)
+  #   domain = Domain.generate
+  #   assert_equal domain.entity_by_name("SpecialFoo"), Domain::Entity.from_models(domain, [VerySpecialFoo]).first.parent
+  # end
 
   # Entity properties ========================================================
   test "connected should return false for unconnected entities" do
@@ -112,42 +120,138 @@ class EntityTest < ActiveSupport::TestCase
     assert_equal [false, false], Domain.generate.entities.map(&:disconnected?)
   end
   
-  test "descendant should return false for regular entities" do
+  test "specialized should return false for regular entities" do
     create_model "Foo"
-    assert_equal false, Entity.new(Domain.new, Foo).descendant?
+    assert_equal false, create_entity(Foo).specialized?
   end
 
-  test "descendant should return false for descended models with distinct tables" do
+  test "specialized should return false for child entities with distinct tables" do
     create_model "Foo", :type => :string
     Object.const_set :SpecialFoo, Class.new(Foo)
     SpecialFoo.class_eval do
       set_table_name "special_foo"
     end
     create_table "special_foo", {}, true
-    assert_equal false, Entity.new(Domain.new, SpecialFoo).descendant?
+    assert_equal false, create_entity(SpecialFoo).specialized?
   end
 
-  test "descendant should return true for child entities" do
+  test "specialized should return true for specialized entities" do
     create_model "Foo", :type => :string
     Object.const_set :SpecialFoo, Class.new(Foo)
-    assert_equal true, Entity.new(Domain.new, SpecialFoo).descendant?
+    assert_equal true, create_entity(SpecialFoo).specialized?
   end
 
-  test "descendant should return true for children of child entities" do
+  test "specialized should return true for specialations of specialized entities" do
     create_model "Foo", :type => :string
     Object.const_set :SpecialFoo, Class.new(Foo)
     Object.const_set :VerySpecialFoo, Class.new(SpecialFoo)
-    assert_equal true, Entity.new(Domain.new, VerySpecialFoo).descendant?
+    assert_equal true, create_entity(VerySpecialFoo).specialized?
+  end
+
+  test "abstract should return true for specialized entity" do
+    create_model "Foo", :type => :string
+    Object.const_set :SpecialFoo, Class.new(Foo)
+    assert_equal true, create_entity(SpecialFoo).abstract?
+  end
+  
+  test "generalized should return false for regular entity" do
+    create_model "Concrete"
+    assert_equal false, create_entity(Concrete).generalized?
+  end
+  
+  test "abstract should return false for regular entity" do
+    create_model "Concrete"
+    assert_equal false, create_entity(Concrete).abstract?
   end
   
   # Attribute processing =====================================================
   test "attributes should return list of attributes" do
     create_model "Bar", :some_column => :integer, :another_column => :string
-    assert_equal [Attribute] * 3, Entity.new(Domain.new, Bar).attributes.collect(&:class)
+    assert_equal [Domain::Attribute] * 3, create_entity(Bar).attributes.collect(&:class)
   end
 
   test "attributes should return attributes sorted by name" do
     create_model "Bar", :some_column => :integer, :another_column => :string
-    assert_equal ["another_column", "id", "some_column"], Entity.new(Domain.new, Bar).attributes.collect(&:name)
+    assert_equal ["another_column", "id", "some_column"], create_entity(Bar).attributes.collect(&:name)
+  end
+
+  # Generalized entity =======================================================
+  test "model should return nil for generalized entity" do
+    assert_nil create_generalized_entity("MyAbstractModel").model
+  end
+  
+  test "name should return given name for generalized entity" do
+    assert_equal "MyAbstractModel", create_generalized_entity("MyAbstractModel").name
+  end
+  
+  test "attributes should return empty array for generalized entity" do
+    assert_equal [], create_generalized_entity("MyAbstractModel").attributes
+  end
+  
+  test "generalized should return true for generalized entity" do
+    assert_equal true, create_generalized_entity("MyAbstractModel").generalized?
+  end
+  
+  test "specialized should return false for generalized entity" do
+    assert_equal false, create_generalized_entity("MyAbstractModel").specialized?
+  end
+  
+  test "abstract should return true for generalized entity" do
+    assert_equal true, create_generalized_entity("MyAbstractModel").abstract?
+  end
+
+  test "relationships should return relationships for generalized entity" do
+    create_model "Stronghold" do
+      has_many :cannons, :as => :defensible
+    end
+    create_model "Cannon", :defensible => :references do
+      belongs_to :defensible, :polymorphic => true
+    end
+
+    domain = Domain.generate
+    defensible = domain.entity_by_name("Defensible")
+    assert_equal domain.relationships, defensible.relationships
+  end
+
+  test "relationships should return relationships for generalized entity in reverse alphabetic order" do
+    create_model "Stronghold" do
+      has_many :cannons, :as => :defensible
+    end
+    create_model "Cannon", :defensible => :references do
+      belongs_to :defensible, :polymorphic => true
+    end
+
+    domain = Domain.generate
+    defensible = domain.entity_by_name("Defensible")
+    assert_equal domain.relationships, defensible.relationships
+  end
+
+  # Children =================================================================
+  test "children should return empty array for regular entities" do
+    create_model "Foo"
+    assert_equal [], create_entity(Foo).children
+  end
+
+  test "children should return inherited entities for regular entities with single table inheritance" do
+    create_model "Beverage", :type => :string
+    create_model "Whisky", Beverage
+    create_model "Beer", Beverage
+    domain = Domain.generate
+    assert_equal [domain.entity_by_name("Beer"), domain.entity_by_name("Whisky")], domain.entity_by_name("Beverage").children
+  end
+
+  test "children should return inherited entities for generalized entities" do
+    create_model "Stronghold" do
+      has_many :cannons, :as => :defensible
+    end
+    create_model "Galleon" do
+      has_many :cannons, :as => :defensible
+    end
+    create_model "Cannon", :defensible => :references do
+      belongs_to :defensible, :polymorphic => true
+    end
+    domain = Domain.generate
+    assert_equal [domain.entity_by_name("Galleon"), domain.entity_by_name("Stronghold")],
+      domain.entity_by_name("Defensible").children
   end
 end