relationship_test.rb in rails-erd-0.4.0

- old
+ new

@@ -1,9 +1,9 @@
 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)
   end
   
@@ -11,29 +11,29 @@
   test "inspect should show source and destination" do
     create_model "Foo", :bar => :references do
       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
     create_model "Foo", :bar => :references do
       belongs_to :bar
     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
     create_model "Foo", :bar => :references do
       belongs_to :bar
     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 ==================================================
   test "mutual should return false for one way relationship" do
     create_model "Foo", :bar => :references do
@@ -136,53 +136,66 @@
       has_many :foos
       has_many :special_foos, :class_name => "Foo", :foreign_key => :bar_id
     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
     create_one_to_one_assoc_domain
     One.class_eval do
       validates_presence_of :other
     end
     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
     create_model "One" do
       has_many :many
     end
     create_model "Many" do
       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
     create_one_to_many_assoc_domain
     One.class_eval do
       validates_presence_of :many
     end
     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
     create_one_to_many_assoc_domain
     One.class_eval do
@@ -190,67 +203,67 @@
 
       # This kind of validation is bizarre, but we support it.
       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
     create_one_to_many_assoc_domain
     One.class_eval do
       validates_presence_of :many
       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
     create_one_to_many_assoc_domain
     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
     create_one_to_many_assoc_domain
     One.class_eval do
       validates_presence_of :many
       validates_length_of :many, :maximum => 17
       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
     create_many_to_many_assoc_domain
     Many.class_eval do
       validates_presence_of :more
     end
     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
     create_many_to_many_assoc_domain
     Many.class_eval do
       validates_length_of :more, :minimum => 3, :maximum => 18
     end
     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
     create_many_to_many_assoc_domain
     Many.class_eval do
@@ -263,45 +276,45 @@
       validates_presence_of :many
       validates_length_of :many, :minimum => 2
       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 =================================
   test "cardinality should be zero-one to zero-many for non mutual relationship with belongs_to association" do
     create_model "One"
     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
     create_model "One" do
       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
     create_model "One" do
       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
     create_table "many_more", :many_id => :integer, :more_id => :integer
     create_model "Many"
     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 ====================================
   test "cardinality should be zero-one to zero-many for conflicting one to many associations" do
     create_model "CreditCard", :person => :references do
@@ -312,11 +325,11 @@
       
       # A person may have a preferred card, but they are still able to have
       # 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
     create_model "Book", :author => :references do
       belongs_to :author
@@ -327,11 +340,11 @@
 
       # The author certainly has books, therefore, this association has a
       # 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
     create_model "Spell", :wizard => :references do
     end
@@ -343,13 +356,29 @@
       # We don't go that far yet. We ignore the lower values and opt for the
       # higher values. It'll be okay. Really... You'll never need this.
       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 ======================================================
   test "cardinality should be one to one for has_one associations" do
     create_one_to_one_assoc_domain
     domain = Domain.generate
 
@@ -412,7 +441,27 @@
       belongs_to :bar
     end
     create_model "Bar"
     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