rails-erd 0.3.0 → 0.4.0

data/test/unit/graphviz_test.rb

@@ -9,7 +9,7 @@ class GraphvizTest < ActiveSupport::TestCase
   
   def teardown
     FileUtils.rm Dir["ERD.*"] rescue nil
-    RailsERD::Diagram.send :remove_const, :Graphviz
+    RailsERD::Diagram.send :remove_const, :Graphviz rescue nil
   end
   
   def diagram(options = {})
@@ -148,6 +148,17 @@ class GraphvizTest < ActiveSupport::TestCase
       FileUtils.rm "foobar.png" rescue nil
     end
   end
+  
+  test "create should abort and complain if output directory does not exist" do
+    message = nil
+    begin
+      create_simple_domain
+      Diagram::Graphviz.create :filename => "does_not_exist/foo"
+    rescue => e
+      message = e.message
+    end
+    assert_match /Output directory 'does_not_exist' does not exist/, message
+  end
 
   # Graphviz output ==========================================================
   test "generate should create directed graph" do
@@ -208,7 +219,7 @@ class GraphvizTest < ActiveSupport::TestCase
     create_model "Lid", :jar => :references do
       belongs_to :jar
     end
-    assert_not_match %r{contents}, find_dot_node(diagram(:attributes => false), "Jar")[:label].to_gv
+    assert_no_match %r{contents}, find_dot_node(diagram(:attributes => false), "Jar")[:label].to_gv
   end
 
   test "generate should create edge for each relationship" do
@@ -237,6 +248,33 @@ class GraphvizTest < ActiveSupport::TestCase
     assert_match %r(\A<\s*<.*\|.*>\s*>\Z)m, find_dot_node(diagram(:orientation => :horizontal), "Author")[:label].to_gv
   end
   
+  test "generate should create edge to generalized entity if polymorphism is true" do
+    create_model "Cannon", :defensible => :references do
+      belongs_to :defensible, :polymorphic => true
+    end
+    create_model "Stronghold" do
+      has_many :cannons, :as => :defensible
+    end
+    create_model "Galleon" do
+      has_many :cannons, :as => :defensible
+    end
+    assert_equal [["Defensible", "Cannon"], ["Defensible", "Galleon"], ["Defensible", "Stronghold"]],
+      find_dot_node_pairs(diagram(:polymorphism => true)).sort
+  end
+
+  test "generate should create edge to each child of generalized entity if polymorphism is false" do
+    create_model "Cannon", :defensible => :references do
+      belongs_to :defensible, :polymorphic => true
+    end
+    create_model "Stronghold" do
+      has_many :cannons, :as => :defensible
+    end
+    create_model "Galleon" do
+      has_many :cannons, :as => :defensible
+    end
+    assert_equal [["Galleon", "Cannon"], ["Stronghold", "Cannon"]], find_dot_node_pairs(diagram).sort
+  end
+  
   # Simple notation style ====================================================
   test "generate should use no style for one to one cardinalities with simple notation" do
     create_one_to_one_assoc_domain
@@ -254,38 +292,38 @@ class GraphvizTest < ActiveSupport::TestCase
   end
 
   # Advanced notation style ===================================================
-  test "generate should use open dots for one to one cardinalities with advanced notation" do
+  test "generate should use open dots for one to one cardinalities with bachman notation" do
     create_one_to_one_assoc_domain
-    assert_equal [["odot", "odot"]], find_dot_edge_styles(diagram(:notation => :advanced))
+    assert_equal [["odot", "odot"]], find_dot_edge_styles(diagram(:notation => :bachman))
   end
 
-  test "generate should use dots for mandatory one to one cardinalities with advanced notation" do
+  test "generate should use dots for mandatory one to one cardinalities with bachman notation" do
     create_one_to_one_assoc_domain
     One.class_eval do
       validates_presence_of :other
     end
-    assert_equal [["odot", "dot"]], find_dot_edge_styles(diagram(:notation => :advanced))
+    assert_equal [["dot", "odot"]], find_dot_edge_styles(diagram(:notation => :bachman))
   end
 
-  test "generate should use normal arrow and open dot head with dot tail for one to many cardinalities with advanced notation" do
+  test "generate should use normal arrow and open dot head with dot tail for one to many cardinalities with bachman notation" do
     create_one_to_many_assoc_domain
-    assert_equal [["odot", "odotnormal"]], find_dot_edge_styles(diagram(:notation => :advanced))
+    assert_equal [["odot", "odotnormal"]], find_dot_edge_styles(diagram(:notation => :bachman))
   end
 
-  test "generate should use normal arrow and dot head for mandatory one to many cardinalities with advanced notation" do
+  test "generate should use normal arrow and dot head for mandatory one to many cardinalities with bachman notation" do
     create_one_to_many_assoc_domain
     One.class_eval do
       validates_presence_of :many
     end
-    assert_equal [["odot", "dotnormal"]], find_dot_edge_styles(diagram(:notation => :advanced))
+    assert_equal [["dot", "odotnormal"]], find_dot_edge_styles(diagram(:notation => :bachman))
   end
 
-  test "generate should use normal arrow and open dot head and tail for many to many cardinalities with advanced notation" do
+  test "generate should use normal arrow and open dot head and tail for many to many cardinalities with bachman notation" do
     create_many_to_many_assoc_domain
-    assert_equal [["odotnormal", "odotnormal"]], find_dot_edge_styles(diagram(:notation => :advanced))
+    assert_equal [["odotnormal", "odotnormal"]], find_dot_edge_styles(diagram(:notation => :bachman))
   end
 
-  test "generate should use normal arrow and dot tail and head for mandatory many to many cardinalities with advanced notation" do
+  test "generate should use normal arrow and dot tail and head for mandatory many to many cardinalities with bachman notation" do
     create_many_to_many_assoc_domain
     Many.class_eval do
       validates_presence_of :more
@@ -293,6 +331,6 @@ class GraphvizTest < ActiveSupport::TestCase
     More.class_eval do
       validates_presence_of :many
     end
-    assert_equal [["dotnormal", "dotnormal"]], find_dot_edge_styles(diagram(:notation => :advanced))
+    assert_equal [["dotnormal", "dotnormal"]], find_dot_edge_styles(diagram(:notation => :bachman))
   end
 end

data/test/unit/rake_task_test.rb

@@ -67,8 +67,8 @@ class RakeTaskTest < ActiveSupport::TestCase
   end
   
   test "options task should set known array command line options" do
-    ENV["attributes"] = "regular,timestamps"
+    ENV["attributes"] = "content,timestamps"
     Rake::Task["erd:options"].execute
-    assert_equal [:regular, :timestamps], RailsERD.options.attributes
+    assert_equal [:content, :timestamps], RailsERD.options.attributes
   end
 end

data/test/unit/relationship_test.rb

@@ -1,7 +1,7 @@
 require File.expand_path("../test_helper", File.dirname(__FILE__))
 
 class RelationshipTest < ActiveSupport::TestCase
-  N = Relationship::N
+  N = Domain::Relationship::N
   
   def domain_cardinalities
     Domain.generate.relationships.map(&:cardinality)
@@ -13,7 +13,7 @@ class RelationshipTest < ActiveSupport::TestCase
       belongs_to :bar
     end
     create_model "Bar"
-    assert_match %r{#<RailsERD::Relationship:.* @source=Bar @destination=Foo>}, Domain.generate.relationships.first.inspect
+    assert_match %r{#<RailsERD::Domain::Relationship:.* @source=Bar @destination=Foo>}, Domain.generate.relationships.first.inspect
   end
   
   test "source should return relationship source" do
@@ -22,7 +22,7 @@ class RelationshipTest < ActiveSupport::TestCase
     end
     create_model "Bar"
     domain = Domain.generate
-    assert_equal [domain.entity_for(Bar)], domain.relationships.map(&:source)
+    assert_equal [domain.entity_by_name("Bar")], domain.relationships.map(&:source)
   end
   
   test "destination should return relationship destination" do
@@ -31,7 +31,7 @@ class RelationshipTest < ActiveSupport::TestCase
     end
     create_model "Bar"
     domain = Domain.generate
-    assert_equal [domain.entity_for(Foo)], domain.relationships.map(&:destination)
+    assert_equal [domain.entity_by_name("Foo")], domain.relationships.map(&:destination)
   end
   
   # Relationship properties ==================================================
@@ -138,11 +138,24 @@ class RelationshipTest < ActiveSupport::TestCase
     end
     assert_equal [4], Domain.generate.relationships.map(&:strength)
   end
+
+  test "strength should count polymorphic associations only once" do
+    create_model "Foo", :bar => :references do
+      belongs_to :bar, :polymorphic => true
+    end
+    create_model "Qux" do
+      has_many :foos, :as => :bar
+    end
+    create_model "Quux" do
+      has_many :foos, :as => :bar
+    end
+    assert_equal [1], Domain.generate.relationships.map(&:strength)
+  end
   
   # Cardinalities ============================================================
   test "cardinality should be zero-one to zero-one for optional one to one associations" do
     create_one_to_one_assoc_domain
-    assert_equal [Relationship::Cardinality.new(0..1, 0..1)], domain_cardinalities
+    assert_equal [Domain::Relationship::Cardinality.new(0..1, 0..1)], domain_cardinalities
   end
 
   test "cardinality should be one to one for mutually mandatory one to one associations" do
@@ -153,12 +166,12 @@ class RelationshipTest < ActiveSupport::TestCase
     Other.class_eval do
       validates_presence_of :one
     end
-    assert_equal [Relationship::Cardinality.new(1, 1)], domain_cardinalities
+    assert_equal [Domain::Relationship::Cardinality.new(1, 1)], domain_cardinalities
   end
 
   test "cardinality should be zero-one to zero-many for optional one to many associations" do
     create_one_to_many_assoc_domain
-    assert_equal [Relationship::Cardinality.new(0..1, 0..N)], domain_cardinalities
+    assert_equal [Domain::Relationship::Cardinality.new(0..1, 0..N)], domain_cardinalities
   end
 
   test "cardinality should be one to zero-many for one to many associations with not null foreign key" do
@@ -169,7 +182,7 @@ class RelationshipTest < ActiveSupport::TestCase
       belongs_to :one
     end
     add_column :manies, :one_id, :integer, :null => false, :default => 0
-    assert_equal [Relationship::Cardinality.new(1, 0..N)], domain_cardinalities
+    assert_equal [Domain::Relationship::Cardinality.new(1, 0..N)], domain_cardinalities
   end
 
   test "cardinality should be one to one-many for mutually mandatory one to many associations" do
@@ -180,7 +193,7 @@ class RelationshipTest < ActiveSupport::TestCase
     Many.class_eval do
       validates_presence_of :one
     end
-    assert_equal [Relationship::Cardinality.new(1, 1..N)], domain_cardinalities
+    assert_equal [Domain::Relationship::Cardinality.new(1, 1..N)], domain_cardinalities
   end
 
   test "cardinality should be zero-one to one-n for maximised one to many associations" do
@@ -192,7 +205,7 @@ class RelationshipTest < ActiveSupport::TestCase
       validates_length_of :many, :maximum => 5
       validates_length_of :many, :maximum => 2  # The lowest maximum should be used.
     end
-    assert_equal [Relationship::Cardinality.new(0..1, 1..2)], domain_cardinalities
+    assert_equal [Domain::Relationship::Cardinality.new(0..1, 1..2)], domain_cardinalities
   end
 
   test "cardinality should be zero-one to n-many for minimised one to many associations" do
@@ -202,7 +215,7 @@ class RelationshipTest < ActiveSupport::TestCase
       validates_length_of :many, :minimum => 2
       validates_length_of :many, :minimum => 5  # The highest minimum should be used.
     end
-    assert_equal [Relationship::Cardinality.new(0..1, 5..N)], domain_cardinalities
+    assert_equal [Domain::Relationship::Cardinality.new(0..1, 5..N)], domain_cardinalities
   end
 
   test "cardinality should be zero-one to n-m for limited one to many associations with single validation" do
@@ -210,7 +223,7 @@ class RelationshipTest < ActiveSupport::TestCase
     One.class_eval do
       validates_length_of :many, :minimum => 5, :maximum => 17
     end
-    assert_equal [Relationship::Cardinality.new(0..1, 5..17)], domain_cardinalities
+    assert_equal [Domain::Relationship::Cardinality.new(0..1, 5..17)], domain_cardinalities
   end
 
   test "cardinality should be zero-one to n-m for limited one to many associations with multiple validations" do
@@ -221,12 +234,12 @@ class RelationshipTest < ActiveSupport::TestCase
       validates_length_of :many, :minimum => 5
       validates_length_of :many, :minimum => 2, :maximum => 28
     end
-    assert_equal [Relationship::Cardinality.new(0..1, 5..17)], domain_cardinalities
+    assert_equal [Domain::Relationship::Cardinality.new(0..1, 5..17)], domain_cardinalities
   end
   
   test "cardinality should be zero-many to zero-many for optional many to many associations" do
     create_many_to_many_assoc_domain
-    assert_equal [Relationship::Cardinality.new(0..N, 0..N)], domain_cardinalities
+    assert_equal [Domain::Relationship::Cardinality.new(0..N, 0..N)], domain_cardinalities
   end
 
   test "cardinality should be one-many to one-many for mutually mandatory many to many associations" do
@@ -237,7 +250,7 @@ class RelationshipTest < ActiveSupport::TestCase
     More.class_eval do
       validates_presence_of :many
     end
-    assert_equal [Relationship::Cardinality.new(1..N, 1..N)], domain_cardinalities
+    assert_equal [Domain::Relationship::Cardinality.new(1..N, 1..N)], domain_cardinalities
   end
   
   test "cardinality should be n-m to n-m for limited many to many associations with single validations" do
@@ -248,7 +261,7 @@ class RelationshipTest < ActiveSupport::TestCase
     More.class_eval do
       validates_length_of :many, :maximum => 29, :minimum => 7
     end
-    assert_equal [Relationship::Cardinality.new(3..18, 7..29)], domain_cardinalities
+    assert_equal [Domain::Relationship::Cardinality.new(3..18, 7..29)], domain_cardinalities
   end
 
   test "cardinality should be n-m to n-m for limited many to many associations with multiple validations" do
@@ -265,7 +278,7 @@ class RelationshipTest < ActiveSupport::TestCase
       validates_length_of :many, :minimum => 9
       validates_length_of :many, :maximum => 17
     end
-    assert_equal [Relationship::Cardinality.new(3..20, 9..17)], domain_cardinalities
+    assert_equal [Domain::Relationship::Cardinality.new(3..20, 9..17)], domain_cardinalities
   end
   
   # Cardinality for non-mutual relationships =================================
@@ -274,7 +287,7 @@ class RelationshipTest < ActiveSupport::TestCase
     create_model "Many", :one => :references do
       belongs_to :one
     end
-    assert_equal [Relationship::Cardinality.new(0..1, 0..N)], domain_cardinalities
+    assert_equal [Domain::Relationship::Cardinality.new(0..1, 0..N)], domain_cardinalities
   end
 
   test "cardinality should be zero-one to zero-many for non mutual relationship with has_many association" do
@@ -282,7 +295,7 @@ class RelationshipTest < ActiveSupport::TestCase
       has_many :many
     end
     create_model "Many", :one => :references
-    assert_equal [Relationship::Cardinality.new(0..1, 0..N)], domain_cardinalities
+    assert_equal [Domain::Relationship::Cardinality.new(0..1, 0..N)], domain_cardinalities
   end
   
   test "cardinality should be zero-one to zero-one for non mutual relationship with has_one association" do
@@ -290,7 +303,7 @@ class RelationshipTest < ActiveSupport::TestCase
       has_one :other
     end
     create_model "Other", :one => :references
-    assert_equal [Relationship::Cardinality.new(0..1, 0..1)], domain_cardinalities
+    assert_equal [Domain::Relationship::Cardinality.new(0..1, 0..1)], domain_cardinalities
   end
   
   test "cardinality should be zero-many to zero-many for non mutual relationship with has_and_belongs_to_many association" do
@@ -299,7 +312,7 @@ class RelationshipTest < ActiveSupport::TestCase
     create_model "More" do
       has_and_belongs_to_many :many
     end
-    assert_equal [Relationship::Cardinality.new(0..N, 0..N)], domain_cardinalities
+    assert_equal [Domain::Relationship::Cardinality.new(0..N, 0..N)], domain_cardinalities
   end
   
   # Cardinality for multiple associations ====================================
@@ -314,7 +327,7 @@ class RelationshipTest < ActiveSupport::TestCase
       # many cards. The association has an infinite maximum cardinality.
       has_one :preferred_credit_card, :class_name => "CreditCard"
     end
-    assert_equal [Relationship::Cardinality.new(0..1, 0..N)], domain_cardinalities
+    assert_equal [Domain::Relationship::Cardinality.new(0..1, 0..N)], domain_cardinalities
   end
 
   test "cardinality should be zero-one to one-many for conflicting validations in one to many associations" do
@@ -329,7 +342,7 @@ class RelationshipTest < ActiveSupport::TestCase
       # minimum cardinality of one.
       validates_presence_of :books
     end
-    assert_equal [Relationship::Cardinality.new(0..1, 1..N)], domain_cardinalities
+    assert_equal [Domain::Relationship::Cardinality.new(0..1, 1..N)], domain_cardinalities
   end
   
   test "cardinality should be n-m to n-m for conflicting validations in one to many associations" do
@@ -345,7 +358,23 @@ class RelationshipTest < ActiveSupport::TestCase
       validates_length_of :ice_spells, :in => 10..20
       validates_length_of :fire_spells, :in => 50..100
     end
-    assert_equal [Relationship::Cardinality.new(0..1, 50..100)], domain_cardinalities
+    assert_equal [Domain::Relationship::Cardinality.new(0..1, 50..100)], domain_cardinalities
+  end
+  
+  test "cardinality should be one to one-many for mandatory one to many associations on polymorphic interfaces" do
+    create_model "Cannon", :defensible => :references do
+      belongs_to :defensible, :polymorphic => true
+      validates_presence_of :defensible
+    end
+    create_model "Stronghold" do
+      has_many :cannons, :as => :defensible
+      validates_presence_of :cannons
+    end
+    create_model "Galleon" do
+      has_many :cannons, :as => :defensible
+      validates_presence_of :cannons
+    end
+    assert_equal [Domain::Relationship::Cardinality.new(1, 1..N)], domain_cardinalities
   end
   
   # Cardinality classes ======================================================
@@ -415,4 +444,24 @@ class RelationshipTest < ActiveSupport::TestCase
     domain = Domain.generate
     assert_equal [:one_to_many], domain.relationships.map(&:cardinality).map(&:name)
   end
+  
+  test "cardinality should be one to many for has_many associations from 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
+
+    assert_equal [:one_to_many], domain.relationships.map(&:cardinality).map(&:name)
+    assert_equal [false], domain.relationships.map(&:one_to_one?)
+    assert_equal [true], domain.relationships.map(&:one_to_many?)
+    assert_equal [false], domain.relationships.map(&:many_to_many?)
+
+    assert_equal [true], domain.relationships.map(&:one_to?)
+    assert_equal [false], domain.relationships.map(&:many_to?)
+    assert_equal [false], domain.relationships.map(&:to_one?)
+    assert_equal [true], domain.relationships.map(&:to_many?)
+  end
 end

data/test/unit/specialization_test.rb

@@ -0,0 +1,57 @@
+require File.expand_path("../test_helper", File.dirname(__FILE__))
+
+class SpecializationTest < ActiveSupport::TestCase
+  # Specialization ===========================================================
+  test "inspect should show source and destination" do
+    create_specialization
+    domain = Domain.generate
+    assert_match %r{#<RailsERD::Domain::Specialization:.* @generalized=Beverage @specialized=Beer>},
+      Domain::Specialization.new(domain, domain.entity_by_name("Beverage"), domain.entity_by_name("Beer")).inspect
+  end
+  
+  test "generalized should return source entity" do
+    create_specialization
+    domain = Domain.generate
+    assert_equal domain.entity_by_name("Beverage"),
+      Domain::Specialization.new(domain, domain.entity_by_name("Beverage"), domain.entity_by_name("Beer")).generalized
+  end
+
+  test "specialized should return destination entity" do
+    create_specialization
+    domain = Domain.generate
+    assert_equal domain.entity_by_name("Beer"),
+      Domain::Specialization.new(domain, domain.entity_by_name("Beverage"), domain.entity_by_name("Beer")).specialized
+  end
+  
+  # Specialization properties ================================================
+  test "inheritance should be true for inheritance specializations" do
+    create_specialization
+    assert_equal [true], Domain.generate.specializations.map(&:inheritance?)
+  end
+
+  test "polymorphic should be false for inheritance specializations" do
+    create_specialization
+    assert_equal [false], Domain.generate.specializations.map(&:polymorphic?)
+  end
+
+  test "inheritance should be false for polymorphic specializations" do
+    create_generalization
+    assert_equal [false], Domain.generate.specializations.map(&:inheritance?)
+  end
+
+  test "polymorphic should be true for polymorphic specializations" do
+    create_generalization
+    assert_equal [true], Domain.generate.specializations.map(&:polymorphic?)
+  end
+  
+  test "inheritance should be false for polymorphic specializations to specialized entities" do
+    create_model "Cannon"
+    create_model "Ship", :type => :string
+    create_model "Galleon", Ship do
+      has_many :cannons, :as => :defensible
+    end
+    domain = Domain.generate
+    assert_equal false, domain.specializations.find { |s|
+      s.generalized == domain.entity_by_name("Defensible") }.inheritance?
+  end
+end