rails-erd 0.2.0 → 0.3.0

data/test/unit/graphviz_test.rb

@@ -2,30 +2,35 @@ require File.expand_path("../test_helper", File.dirname(__FILE__))
 
 class GraphvizTest < ActiveSupport::TestCase
   def setup
-    RailsERD.options.file_type = :dot
+    RailsERD.options.filetype = :png
+    RailsERD.options.warn = false
     load "rails_erd/diagram/graphviz.rb"
   end
   
   def teardown
-    FileUtils.rm "ERD.dot" rescue nil
+    FileUtils.rm Dir["ERD.*"] rescue nil
     RailsERD::Diagram.send :remove_const, :Graphviz
   end
   
-  def diagram
-    @diagram ||= Diagram::Graphviz.new(Domain.generate).tap do |diagram|
+  def diagram(options = {})
+    @diagram ||= Diagram::Graphviz.new(Domain.generate(options), options).tap do |diagram|
       diagram.generate
     end
   end
   
   def find_dot_nodes(diagram)
     [].tap do |nodes|
-      diagram.graph.each_node do |node|
+      diagram.graph.each_node do |name, node|
         nodes << node
       end
     end
   end
 
-  def find_dot_edges(diagram)
+  def find_dot_node(diagram, name)
+    diagram.graph.get_node(name)
+  end
+
+  def find_dot_node_pairs(diagram)
     [].tap do |edges|
       diagram.graph.each_edge do |edge|
         edges << [edge.node_one, edge.node_two]
@@ -33,56 +38,95 @@ class GraphvizTest < ActiveSupport::TestCase
     end
   end
   
+  def find_dot_edges(diagram)
+    [].tap do |edges|
+      diagram.graph.each_edge do |edge|
+        edges << edge
+      end
+    end
+  end
+  
+  def find_dot_edge_styles(diagram)
+    find_dot_edges(diagram).map { |e| [e[:arrowtail].to_s.tr('"', ''), e[:arrowhead].to_s.tr('"', '')] }
+  end
+
   # Diagram properties =======================================================
   test "file name should depend on file type" do
     create_simple_domain
     begin
-      assert_equal "ERD.svg", Diagram::Graphviz.create(:file_type => :svg)
+      assert_equal "ERD.svg", Diagram::Graphviz.create(:filetype => :svg)
     ensure
       FileUtils.rm "ERD.svg" rescue nil
     end
   end
   
+  test "rank direction should be lr for horizontal orientation" do
+    create_simple_domain
+    assert_equal '"LR"', diagram(:orientation => :horizontal).graph[:rankdir].to_s
+  end
+
+  test "rank direction should be tb for vertical orientation" do
+    create_simple_domain
+    assert_equal '"TB"', diagram(:orientation => :vertical).graph[:rankdir].to_s
+  end
+  
   # Diagram generation =======================================================
-  test "create should create output based on domain model" do
+  test "create should create output for domain with attributes" do
     create_model "Foo", :bar => :references, :column => :string do
       belongs_to :bar
     end
     create_model "Bar", :column => :string
     Diagram::Graphviz.create
-    assert File.exists?("ERD.dot")
+    assert File.exists?("ERD.png")
   end
 
-  test "create should create output based on domain without attributes" do
-    create_model "Foo", :bar => :references do
-      belongs_to :bar
-    end
-    create_model "Bar"
+  test "create should create output for domain without attributes" do
+    create_simple_domain
     Diagram::Graphviz.create
+    assert File.exists?("ERD.png")
+  end
+  
+  test "create should write to file with dot extension if type is dot" do
+    create_simple_domain
+    Diagram::Graphviz.create :filetype => :dot
     assert File.exists?("ERD.dot")
   end
+
+  test "create should write to file with dot extension without requiring graphviz" do
+    create_simple_domain
+    begin
+      GraphViz.class_eval do
+        alias_method :old_output_and_errors_from_command, :output_and_errors_from_command
+        def output_and_errors_from_command(*args); raise end
+      end
+      assert_nothing_raised do
+        Diagram::Graphviz.create :filetype => :dot
+      end
+    ensure
+      GraphViz.class_eval do
+        alias_method :output_and_errors_from_command, :old_output_and_errors_from_command
+      end
+    end
+  end
   
-  test "create should create vertical output based on domain model" do
+  test "create should create output for domain with attributes if orientation is vertical" do
     create_model "Foo", :bar => :references, :column => :string do
       belongs_to :bar
     end
     create_model "Bar", :column => :string
     Diagram::Graphviz.create(:orientation => :vertical)
-    assert File.exists?("ERD.dot")
+    assert File.exists?("ERD.png")
   end
 
-  test "create should create vertical output based on domain without attributes" do
-    create_model "Foo", :bar => :references do
-      belongs_to :bar
-    end
-    create_model "Bar"
+  test "create should create output for domain if orientation is vertical" do
+    create_simple_domain
     Diagram::Graphviz.create(:orientation => :vertical)
-    assert File.exists?("ERD.dot")
+    assert File.exists?("ERD.png")
   end
 
   test "create should not create output if there are no connected models" do
     Diagram::Graphviz.create rescue nil
-    assert !File.exists?("ERD.dot")
+    assert !File.exists?("ERD.png")
   end
 
   test "create should abort and complain if there are no connected models" do
@@ -92,21 +136,55 @@ class GraphvizTest < ActiveSupport::TestCase
     rescue => e
       message = e.message
     end
-    assert_match /No \(connected\) entities found/, message
+    assert_match /No entities found/, message
   end
   
+  test "create should write to given file name plus extension if present" do
+    begin
+      create_simple_domain
+      Diagram::Graphviz.create :filename => "foobar"
+      assert File.exists?("foobar.png")
+    ensure
+      FileUtils.rm "foobar.png" rescue nil
+    end
+  end
+
   # Graphviz output ==========================================================
   test "generate should create directed graph" do
     create_simple_domain
     assert_equal "digraph", diagram.graph.type
   end
   
+  test "generate should add title to graph" do
+    create_simple_domain
+    assert_equal '"Domain model\n\n"', diagram.graph.graph[:label].to_s
+  end
+
+  test "generate should add title with application name to graph" do
+    begin
+      Object::Quux = Module.new
+      Object::Quux::Application = Class.new
+      Object::Rails = Struct.new(:application).new(Object::Quux::Application.new)
+      create_simple_domain
+      assert_equal '"Quux domain model\n\n"', diagram.graph.graph[:label].to_s
+    ensure
+      Object::Quux.send :remove_const, :Application
+      Object.send :remove_const, :Quux
+      Object.send :remove_const, :Rails
+    end
+  end
+
+  test "generate should omit title if set to false" do
+    create_simple_domain
+    assert_equal "", diagram(:title => false).graph.graph[:label].to_s
+  end
+  
   test "generate should create node for each entity" do
     create_model "Foo", :bar => :references do
       belongs_to :bar
     end
     create_model "Bar"
-    assert_equal ["Bar", "Foo"], find_dot_nodes(diagram).sort
+    assert_equal ["Bar", "Foo"], find_dot_nodes(diagram).map(&:id).sort
   end
   
   test "generate should add label for entities" do
@@ -114,8 +192,7 @@ class GraphvizTest < ActiveSupport::TestCase
       belongs_to :bar
     end
     create_model "Bar"
-    assert_match %r{<\w+.*?>Bar</\w+>},
-      diagram.graph.get_node(find_dot_nodes(diagram).first)[:label].to_gv
+    assert_match %r{<\w+.*?>Bar</\w+>}, find_dot_node(diagram, "Bar")[:label].to_gv
   end
 
   test "generate should add attributes to entity labels" do
@@ -123,10 +200,16 @@ class GraphvizTest < ActiveSupport::TestCase
       belongs_to :bar
     end
     create_model "Bar", :column => :string
-    assert_match %r{<\w+.*?>column <\w+.*?>str</\w+.*?>},
-      diagram.graph.get_node(find_dot_nodes(diagram).first)[:label].to_gv
+    assert_match %r{<\w+.*?>column <\w+.*?>string</\w+.*?>}, find_dot_node(diagram, "Bar")[:label].to_gv
   end
 
+  test "generate should not add any attributes to entity labels if attributes is set to false" do
+    create_model "Jar", :contents => :string
+    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
+  end
 
   test "generate should create edge for each relationship" do
     create_model "Foo", :bar => :references do
@@ -135,6 +218,81 @@ class GraphvizTest < ActiveSupport::TestCase
     create_model "Bar", :foo => :references do
       belongs_to :foo
     end
-    assert_equal [["Bar", "Foo"], ["Foo", "Bar"]], find_dot_edges(diagram).sort
+    assert_equal [["Bar", "Foo"], ["Foo", "Bar"]], find_dot_node_pairs(diagram).sort
+  end
+  
+  test "node records should have direction reversing braces for vertical orientation" do
+    create_model "Book", :author => :references do
+      belongs_to :author
+    end
+    create_model "Author", :name => :string
+    assert_match %r(\A<\{\s*<.*\|.*>\s*\}>\Z)m, find_dot_node(diagram(:orientation => :vertical), "Author")[:label].to_gv
+  end
+
+  test "node records should not have direction reversing braces for horizontal orientation" do
+    create_model "Book", :author => :references do
+      belongs_to :author
+    end
+    create_model "Author", :name => :string
+    assert_match %r(\A<\s*<.*\|.*>\s*>\Z)m, find_dot_node(diagram(:orientation => :horizontal), "Author")[:label].to_gv
+  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
+    assert_equal [["none", "none"]], find_dot_edge_styles(diagram(:notation => :simple))
+  end
+
+  test "generate should use normal arrow head for one to many cardinalities with simple notation" do
+    create_one_to_many_assoc_domain
+    assert_equal [["none", "normal"]], find_dot_edge_styles(diagram(:notation => :simple))
+  end
+
+  test "generate should use normal arrow head and tail for many to many cardinalities with simple notation" do
+    create_many_to_many_assoc_domain
+    assert_equal [["normal", "normal"]], find_dot_edge_styles(diagram(:notation => :simple))
+  end
+
+  # Advanced notation style ===================================================
+  test "generate should use open dots for one to one cardinalities with advanced notation" do
+    create_one_to_one_assoc_domain
+    assert_equal [["odot", "odot"]], find_dot_edge_styles(diagram(:notation => :advanced))
+  end
+
+  test "generate should use dots for mandatory one to one cardinalities with advanced 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))
+  end
+
+  test "generate should use normal arrow and open dot head with dot tail for one to many cardinalities with advanced notation" do
+    create_one_to_many_assoc_domain
+    assert_equal [["odot", "odotnormal"]], find_dot_edge_styles(diagram(:notation => :advanced))
+  end
+
+  test "generate should use normal arrow and dot head for mandatory one to many cardinalities with advanced 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))
+  end
+
+  test "generate should use normal arrow and open dot head and tail for many to many cardinalities with advanced notation" do
+    create_many_to_many_assoc_domain
+    assert_equal [["odotnormal", "odotnormal"]], find_dot_edge_styles(diagram(:notation => :advanced))
+  end
+
+  test "generate should use normal arrow and dot tail and head for mandatory many to many cardinalities with advanced notation" 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 [["dotnormal", "dotnormal"]], find_dot_edge_styles(diagram(:notation => :advanced))
   end
 end

data/test/unit/rake_task_test.rb

@@ -7,8 +7,8 @@ class RakeTaskTest < ActiveSupport::TestCase
     require "rake"
     load "rails_erd/tasks.rake"
 
-    RailsERD.options.file_type = :dot
-    RailsERD.options.suppress_warnings = true
+    RailsERD.options.filetype = :dot
+    RailsERD.options.warn = false
     Rake.application.options.silent = true
   end
 
@@ -28,4 +28,47 @@ class RakeTaskTest < ActiveSupport::TestCase
     Rake::Task["erd:generate"].execute rescue nil
     assert !File.exists?("ERD.dot")
   end
+  
+  # Option processing ========================================================
+  test "options task should ignore unknown command line options" do
+    ENV["unknownoption"] = "value"
+    Rake::Task["erd:options"].execute
+    assert_nil RailsERD.options.unknownoption
+  end
+
+  test "options task should set known command line options" do
+    ENV["filetype"] = "myfiletype"
+    Rake::Task["erd:options"].execute
+    assert_equal :myfiletype, RailsERD.options.filetype
+  end
+
+  test "options task should set known boolean command line options if false" do
+    ENV["title"] = "false"
+    Rake::Task["erd:options"].execute
+    assert_equal false, RailsERD.options.title
+  end
+
+  test "options task should set known boolean command line options if true" do
+    ENV["title"] = "true"
+    Rake::Task["erd:options"].execute
+    assert_equal true, RailsERD.options.title
+  end
+
+  test "options task should set known boolean command line options if no" do
+    ENV["title"] = "no"
+    Rake::Task["erd:options"].execute
+    assert_equal false, RailsERD.options.title
+  end
+
+  test "options task should set known boolean command line options if yes" do
+    ENV["title"] = "yes"
+    Rake::Task["erd:options"].execute
+    assert_equal true, RailsERD.options.title
+  end
+  
+  test "options task should set known array command line options" do
+    ENV["attributes"] = "regular,timestamps"
+    Rake::Task["erd:options"].execute
+    assert_equal [:regular, :timestamps], RailsERD.options.attributes
+  end
 end

data/test/unit/relationship_test.rb

@@ -1,14 +1,19 @@
 require File.expand_path("../test_helper", File.dirname(__FILE__))
 
 class RelationshipTest < ActiveSupport::TestCase
+  N = Relationship::N
+  
+  def domain_cardinalities
+    Domain.generate.relationships.map(&:cardinality)
+  end
+  
   # Relationship =============================================================
   test "inspect should show source and destination" do
     create_model "Foo", :bar => :references do
       belongs_to :bar
     end
     create_model "Bar"
-    domain = Domain.generate
-    assert_match %r{#<RailsERD::Relationship:.* @source=Bar @destination=Foo>}, domain.relationships.first.inspect
+    assert_match %r{#<RailsERD::Relationship:.* @source=Bar @destination=Foo>}, Domain.generate.relationships.first.inspect
   end
   
   test "source should return relationship source" do
@@ -35,8 +40,7 @@ class RelationshipTest < ActiveSupport::TestCase
       belongs_to :bar
     end
     create_model "Bar"
-    domain = Domain.generate
-    assert_equal [false], domain.relationships.map(&:mutual?)
+    assert_equal [false], Domain.generate.relationships.map(&:mutual?)
   end
   
   test "mutual should return true for mutual relationship" do
@@ -46,8 +50,12 @@ class RelationshipTest < ActiveSupport::TestCase
     create_model "Bar" do
       has_many :foos
     end
-    domain = Domain.generate
-    assert_equal [true], domain.relationships.map(&:mutual?)
+    assert_equal [true], Domain.generate.relationships.map(&:mutual?)
+  end
+  
+  test "mutual should return true for mutual many to many relationship" do
+    create_many_to_many_assoc_domain
+    assert_equal [true], Domain.generate.relationships.map(&:mutual?)
   end
   
   test "recursive should return false for ordinary relationship" do
@@ -57,16 +65,14 @@ class RelationshipTest < ActiveSupport::TestCase
     create_model "Bar" do
       has_many :foos
     end
-    domain = Domain.generate
-    assert_equal [false], domain.relationships.map(&:recursive?)
+    assert_equal [false], Domain.generate.relationships.map(&:recursive?)
   end
   
   test "recursive should return true for self referencing relationship" do
     create_model "Foo", :foo => :references do
       belongs_to :foo
     end
-    domain = Domain.generate
-    assert_equal [true], domain.relationships.map(&:recursive?)
+    assert_equal [true], Domain.generate.relationships.map(&:recursive?)
   end
   
   test "indirect should return false for ordinary relationship" do
@@ -76,8 +82,7 @@ class RelationshipTest < ActiveSupport::TestCase
     create_model "Bar" do
       has_many :foos
     end
-    domain = Domain.generate
-    assert_equal [false], domain.relationships.map(&:indirect?)
+    assert_equal [false], Domain.generate.relationships.map(&:indirect?)
   end
   
   test "indirect should return false for non mutual ordinary relationship" do
@@ -85,8 +90,7 @@ class RelationshipTest < ActiveSupport::TestCase
       belongs_to :bar
     end
     create_model "Bar"
-    domain = Domain.generate
-    assert_equal [false], domain.relationships.map(&:indirect?)
+    assert_equal [false], Domain.generate.relationships.map(&:indirect?)
   end
   
   test "indirect should return true if relationship is a through association" do
@@ -101,8 +105,7 @@ class RelationshipTest < ActiveSupport::TestCase
     create_model "Baz" do
       has_many :foos
     end
-    domain = Domain.generate
-    assert_equal true, domain.relationships.find { |rel|
+    assert_equal true, Domain.generate.relationships.find { |rel|
       rel.source.model == Bar and rel.destination.model == Baz }.indirect?
   end
   
@@ -111,8 +114,7 @@ class RelationshipTest < ActiveSupport::TestCase
     create_model "Bar" do
       has_many :foos
     end
-    domain = Domain.generate
-    assert_equal [1], domain.relationships.map(&:strength)
+    assert_equal [1], Domain.generate.relationships.map(&:strength)
   end
 
   test "strength should return two for relationship with two associations" do
@@ -122,8 +124,7 @@ class RelationshipTest < ActiveSupport::TestCase
     create_model "Bar" do
       has_many :foos
     end
-    domain = Domain.generate
-    assert_equal [2], domain.relationships.map(&:strength)
+    assert_equal [2], Domain.generate.relationships.map(&:strength)
   end
 
   test "strength should return number of associations that make up the relationship" do
@@ -135,183 +136,283 @@ class RelationshipTest < ActiveSupport::TestCase
       has_many :foos
       has_many :special_foos, :class_name => "Foo", :foreign_key => :bar_id
     end
-    domain = Domain.generate
-    assert_equal [4], domain.relationships.map(&:strength)
+    assert_equal [4], Domain.generate.relationships.map(&:strength)
   end
   
-  # Cardinality ==============================================================
-  test "cardinality should return one to one for has_one associations" do
-    create_model "Foo", :bar => :references
-    create_model "Bar" do
-      has_one :foo
+  # 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
+  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
-    domain = Domain.generate
-    assert_equal [Relationship::Cardinality::OneToOne], domain.relationships.map(&:cardinality)
+    Other.class_eval do
+      validates_presence_of :one
+    end
+    assert_equal [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
+  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
+  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
+  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
+      validates_presence_of :many
+
+      # 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
+  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
+  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
+  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
   end
   
-  test "cardinality should return one to many for has_many associations" do
-    create_model "Foo", :bar => :references
-    create_model "Bar" do
-      has_many :foos
+  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
+  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
-    domain = Domain.generate
-    assert_equal [Relationship::Cardinality::OneToMany], domain.relationships.map(&:cardinality)
+    More.class_eval do
+      validates_presence_of :many
+    end
+    assert_equal [Relationship::Cardinality.new(1..N, 1..N)], domain_cardinalities
   end
   
-  test "cardinality should return many to many for has_and_belongs_to_many associations" do
-    create_table "bars_foos", :foo_id => :integer, :bar_id => :integer
-    create_model "Foo" do
-      has_and_belongs_to_many :bars
+  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
-    create_model "Bar" do
-      has_and_belongs_to_many :foos
+    More.class_eval do
+      validates_length_of :many, :maximum => 29, :minimum => 7
+    end
+    assert_equal [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
+      validates_presence_of :more
+      validates_length_of :more, :minimum => 3
+      validates_length_of :more, :maximum => 20
+      validates_length_of :more, :maximum => 33
+    end
+    More.class_eval do
+      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
+  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
+  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
+  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
+  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
+  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
+      belongs_to :person
+    end
+    create_model "Person" do
+      has_many :credit_cards
+      
+      # 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
+  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
+    end
+    create_model "Author" do
+      has_many :books
+      has_many :published_books, :class_name => "Book"
+
+      # 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
+  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
+    create_model "Wizard" do
+      has_many :ice_spells, :class_name => "Spell"
+      has_many :fire_spells, :class_name => "Spell"
+      
+      # Well, this can make sense, based on the conditions for the associations.
+      # 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
+  end
+  
+  # Cardinality classes ======================================================
+  test "cardinality should be one to one for has_one associations" do
+    create_one_to_one_assoc_domain
     domain = Domain.generate
-    assert_equal [Relationship::Cardinality::ManyToMany], domain.relationships.map(&:cardinality)
+
+    # In these test, we are liberal with the number of assertions per test.
+    assert_equal [:one_to_one], domain.relationships.map(&:cardinality).map(&:name)
+
+    assert_equal [true], domain.relationships.map(&:one_to_one?)
+    assert_equal [false], 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 [true], domain.relationships.map(&:to_one?)
+    assert_equal [false], domain.relationships.map(&:to_many?)
   end
   
-  test "cardinality should return one to many for multiple associations with maximum cardinality of has_many" do
+  test "cardinality should be one to many for has_many associations" do
+    create_one_to_many_assoc_domain
+    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
+  
+  test "cardinality should be many to many for has_and_belongs_to_many associations" do
+    create_many_to_many_assoc_domain
+    domain = Domain.generate
+
+    assert_equal [:many_to_many], domain.relationships.map(&:cardinality).map(&:name)
+
+    assert_equal [false], domain.relationships.map(&:one_to_one?)
+    assert_equal [false], domain.relationships.map(&:one_to_many?)
+    assert_equal [true], domain.relationships.map(&:many_to_many?)
+
+    assert_equal [false], domain.relationships.map(&:one_to?)
+    assert_equal [true], domain.relationships.map(&:many_to?)
+    assert_equal [false], domain.relationships.map(&:to_one?)
+    assert_equal [true], domain.relationships.map(&:to_many?)
+  end
+  
+  test "cardinality should be one to many for multiple associations with maximum cardinality of has_many" do
     create_model "Foo", :bar => :references
     create_model "Bar" do
       has_one :foo
       has_many :foos
     end
     domain = Domain.generate
-    assert_equal [Relationship::Cardinality::OneToMany], domain.relationships.map(&:cardinality)
+    assert_equal [:one_to_many], domain.relationships.map(&:cardinality).map(&:name)
   end
   
-  test "cardinality should return one to many if forward association is missing" do
+  test "cardinality should be one to many if forward association is missing" do
     create_model "Foo", :bar => :references do
       belongs_to :bar
     end
     create_model "Bar"
     domain = Domain.generate
-    assert_equal [Relationship::Cardinality::OneToMany], domain.relationships.map(&:cardinality)
+    assert_equal [:one_to_many], domain.relationships.map(&:cardinality).map(&:name)
   end
-  
-  # test "cardinality should return zero or more for has_many association" do
-  #   create_model "Foo", :bar => :references do
-  #     belongs_to :bar
-  #   end
-  #   create_model "Bar" do
-  #     has_many :foos
-  #   end
-  #   domain = Domain.generate
-  #   assert_equal Cardinality::ZeroOrMore, domain.relationships.first.cardinality
-  # end
-  # 
-  # test "cardinality should return one or more for validated has_many association" do
-  #   create_model "Foo", :bar => :references do
-  #     belongs_to :bar
-  #   end
-  #   create_model "Bar" do
-  #     has_many :foos
-  #     validates :foos, :presence => true
-  #   end
-  #   domain = Domain.generate
-  #   assert_equal Cardinality::OneOrMore, domain.relationships.first.cardinality
-  # end
-  # 
-  # test "cardinality should return zero or more for has_many association with foreign database constraint" do
-  #   create_model "Foo" do
-  #     belongs_to :bar
-  #   end
-  #   add_column :foos, :bar_id, :integer, :null => false, :default => 0
-  #   create_model "Bar" do
-  #     has_many :foos
-  #   end
-  #   domain = Domain.generate
-  #   assert_equal Cardinality::ZeroOrMore, domain.relationships.first.cardinality
-  # end
-  # 
-  # test "cardinality should return zero or one for has_one association" do
-  #   create_model "Foo", :bar => :references do
-  #     belongs_to :bar
-  #   end
-  #   create_model "Bar" do
-  #     has_one :foo
-  #   end
-  #   domain = Domain.generate
-  #   assert_equal Cardinality::ZeroOrOne, domain.relationships.first.cardinality
-  # end
-  # 
-  # test "cardinality should return exactly one for validated has_one association" do
-  #   create_model "Foo", :bar => :references do
-  #     belongs_to :bar
-  #   end
-  #   create_model "Bar" do
-  #     has_one :foo
-  #     validates :foo, :presence => true
-  #   end
-  #   domain = Domain.generate
-  #   assert_equal Cardinality::ExactlyOne, domain.relationships.first.cardinality
-  # end
-  # 
-  # test "cardinality should return exactly one for has_one association with foreign database constraint" do
-  #   create_model "Foo" do
-  #     belongs_to :bar
-  #   end
-  #   add_column :foos, :bar_id, :integer, :null => false, :default => 0
-  #   create_model "Bar" do
-  #     has_one :foo
-  #   end
-  #   domain = Domain.generate
-  #   assert_equal Cardinality::ZeroOrOne, domain.relationships.first.cardinality
-  # end
-  # 
-  # # Reverse cardinality ======================================================
-  # test "reverse_cardinality should return nil if reverse association is missing" do
-  #   create_model "Foo", :bar => :references
-  #   create_model "Bar" do
-  #     has_many :foos
-  #   end
-  #   domain = Domain.generate
-  #   assert_nil domain.relationships.first.reverse_cardinality
-  # end
-  # 
-  # test "reverse_cardinality should return zero or one for has_many association" do
-  #   create_model "Foo", :bar => :references do
-  #     belongs_to :bar
-  #   end
-  #   create_model "Bar" do
-  #     has_many :foos
-  #   end
-  #   domain = Domain.generate
-  #   assert_equal Cardinality::ZeroOrOne, domain.relationships.first.reverse_cardinality
-  # end
-  # 
-  # test "reverse_cardinality should return exactly one for validated has_many association" do
-  #   create_model "Foo", :bar => :references do
-  #     belongs_to :bar
-  #     validates :bar, :presence => true
-  #   end
-  #   create_model "Bar" do
-  #     has_many :foos
-  #   end
-  #   domain = Domain.generate
-  #   assert_equal Cardinality::ExactlyOne, domain.relationships.first.reverse_cardinality
-  # end
-  # 
-  # test "reverse_cardinality should return zero or one for has_one association" do
-  #   create_model "Foo", :bar => :references do
-  #     belongs_to :bar
-  #   end
-  #   create_model "Bar" do
-  #     has_one :foo
-  #   end
-  #   domain = Domain.generate
-  #   assert_equal Cardinality::ZeroOrOne, domain.relationships.first.reverse_cardinality
-  # end
-  # 
-  # test "reverse_cardinality should return exactly one for validated has_one association" do
-  #   create_model "Foo", :bar => :references do
-  #     belongs_to :bar
-  #     validates :bar, :presence => true
-  #   end
-  #   create_model "Bar" do
-  #     has_one :foo
-  #   end
-  #   domain = Domain.generate
-  #   assert_equal Cardinality::ExactlyOne, domain.relationships.first.reverse_cardinality
-  # end
 end