rails-erd 0.2.0 → 0.3.0

data/test/unit/attribute_test.rb

@@ -115,7 +115,7 @@ class AttributeTest < ActiveSupport::TestCase
   # Type descriptions ========================================================
   test "type_description should return short type description" do
     create_model "Foo", :a => :binary
-    assert_equal "blob", create_attribute(Foo, "a").type_description
+    assert_equal "binary", create_attribute(Foo, "a").type_description
   end
 
   test "type_description should return short type description without limit if standard" do
@@ -123,7 +123,7 @@ class AttributeTest < ActiveSupport::TestCase
       create_model "Foo"
       add_column :foos, :my_str, :string, :limit => 255
       ActiveRecord::Base.connection.native_database_types[:string]
-      assert_equal "str (255)", create_attribute(Foo, "my_str").type_description
+      assert_equal "string (255)", create_attribute(Foo, "my_str").type_description
     end
   end
 
@@ -131,7 +131,7 @@ class AttributeTest < ActiveSupport::TestCase
     with_native_limit :string, 456 do
       create_model "Foo"
       add_column :foos, :my_str, :string, :limit => 456
-      assert_equal "str", create_attribute(Foo, "my_str").type_description
+      assert_equal "string", create_attribute(Foo, "my_str").type_description
     end
   end
   
@@ -139,6 +139,28 @@ class AttributeTest < ActiveSupport::TestCase
     create_model "Foo", :a => :integer do
       validates_presence_of :a
     end
-    assert_equal "int ∗", create_attribute(Foo, "a").type_description
+    assert_equal "integer ∗", create_attribute(Foo, "a").type_description
+  end
+  
+  test "limit should return nil if there is no limit" do
+    create_model "Foo"
+    add_column :foos, :my_txt, :text
+    assert_equal nil, create_attribute(Foo, "my_txt").limit
+  end
+  
+  test "limit should return nil if equal to standard database limit" do
+    with_native_limit :string, 456 do
+      create_model "Foo"
+      add_column :foos, :my_str, :string, :limit => 456
+      assert_equal nil, create_attribute(Foo, "my_str").limit
+    end
+  end
+  
+  test "limit should return limit if nonstandard" do
+    with_native_limit :string, 456 do
+      create_model "Foo"
+      add_column :foos, :my_str, :string, :limit => 255
+      assert_equal 255, create_attribute(Foo, "my_str").limit
+    end
   end
 end

data/test/unit/cardinality_test.rb

@@ -1,25 +1,117 @@
 require File.expand_path("../test_helper", File.dirname(__FILE__))
 
 class CardinalityTest < ActiveSupport::TestCase
-  # Cardinality order ========================================================
-  test "cardinalities should be sorted in order of maniness" do
-    assert_equal [Relationship::Cardinality::OneToOne, Relationship::Cardinality::OneToMany, Relationship::Cardinality::ManyToMany],
-      [Relationship::Cardinality::OneToMany, Relationship::Cardinality::ManyToMany, Relationship::Cardinality::OneToOne].sort
+  def setup
+    @n = Relationship::Cardinality::N
+  end
+  
+  # Cardinality construction =================================================
+  test "new should return cardinality object" do
+    assert_kind_of Relationship::Cardinality, Relationship::Cardinality.new(1, 1..@n)
   end
   
   # Cardinality properties ===================================================
-  test "one_to_one should return true for one to one cardinalities" do
-    assert_equal [true, false, false], [Relationship::Cardinality::OneToOne,
-      Relationship::Cardinality::OneToMany, Relationship::Cardinality::ManyToMany].map(&:one_to_one?)
+  test "source_optional should return true if source range starts at zero" do
+    assert_equal true, Relationship::Cardinality.new(0..1, 1).source_optional?
+  end
+
+  test "source_optional should return false if source range starts at one or more" do
+    assert_equal false, Relationship::Cardinality.new(1..2, 0..1).source_optional?
+  end
+
+  test "destination_optional should return true if destination range starts at zero" do
+    assert_equal true, Relationship::Cardinality.new(1, 0..1).destination_optional?
+  end
+
+  test "destination_optional should return false if destination range starts at one or more" do
+    assert_equal false, Relationship::Cardinality.new(0..1, 1..2).destination_optional?
+  end
+  
+  test "inverse should return inverse cardinality" do
+    assert_equal Relationship::Cardinality.new(23..45, 0..15), Relationship::Cardinality.new(0..15, 23..45).inverse
+  end
+  
+  # Cardinality equality =====================================================
+  test "cardinalities are equal if they have the same boundaries" do
+    assert_equal Relationship::Cardinality.new(1, 1..Relationship::Cardinality::N),
+      Relationship::Cardinality.new(1, 1..Relationship::Cardinality::N)
+  end
+
+  test "cardinalities are not equal if they have a different source range" do
+    assert_not_equal Relationship::Cardinality.new(0..1, 1..Relationship::Cardinality::N),
+      Relationship::Cardinality.new(1..1, 1..Relationship::Cardinality::N)
+  end
+
+  test "cardinalities are not equal if they have a different destination range" do
+    assert_not_equal Relationship::Cardinality.new(0..1, 1..Relationship::Cardinality::N),
+      Relationship::Cardinality.new(0..1, 2..Relationship::Cardinality::N)
+  end
+  
+  # Cardinal names ===========================================================
+  test "one_to_one should return true if source and destination are exactly one" do
+    assert_equal true, Relationship::Cardinality.new(1, 1).one_to_one?
+  end
+
+  test "one_to_one should return true if source and destination range are less than or equal to one" do
+    assert_equal true, Relationship::Cardinality.new(0..1, 0..1).one_to_one?
   end
 
-  test "one_to_many should return true for one to many cardinalities" do
-    assert_equal [false, true, false], [Relationship::Cardinality::OneToOne,
-      Relationship::Cardinality::OneToMany, Relationship::Cardinality::ManyToMany].map(&:one_to_many?)
+  test "one_to_one should return false if source range upper limit is more than one" do
+    assert_equal false, Relationship::Cardinality.new(0..15, 0..1).one_to_one?
+  end
+  
+  test "one_to_one should return false if destination range upper limit is more than one" do
+    assert_equal false, Relationship::Cardinality.new(0..1, 0..15).one_to_one?
+  end
+  
+  test "one_to_many should return true if source is exactly one and destination is higher than one" do
+    assert_equal true, Relationship::Cardinality.new(1, 15).one_to_many?
+  end
+
+  test "one_to_many should return true if source is less than or equal to one and destination is higher than one" do
+    assert_equal true, Relationship::Cardinality.new(0..1, 0..15).one_to_many?
+  end
+
+  test "one_to_many should return false if source range upper limit is more than one" do
+    assert_equal false, Relationship::Cardinality.new(0..15, 0..15).one_to_many?
+  end
+  
+  test "one_to_many should return false if destination range upper limit is one" do
+    assert_equal false, Relationship::Cardinality.new(0..1, 1).one_to_many?
+  end
+
+  test "many_to_many should return true if source and destination are higher than one" do
+    assert_equal true, Relationship::Cardinality.new(15, 15).many_to_many?
+  end
+
+  test "many_to_many should return true if source and destination upper limits are higher than one" do
+    assert_equal true, Relationship::Cardinality.new(0..15, 0..15).many_to_many?
   end
 
-  test "many_to_many should return true for many to many cardinalities" do
-    assert_equal [false, false, true], [Relationship::Cardinality::OneToOne,
-      Relationship::Cardinality::OneToMany, Relationship::Cardinality::ManyToMany].map(&:many_to_many?)
+  test "many_to_many should return false if source range upper limit is is one" do
+    assert_equal false, Relationship::Cardinality.new(1, 0..15).many_to_many?
+  end
+  
+  test "many_to_many should return false if destination range upper limit is one" do
+    assert_equal false, Relationship::Cardinality.new(0..1, 1).many_to_many?
+  end
+  
+  test "inverse of one_to_many should be many_to_one" do
+    assert_equal true, Relationship::Cardinality.new(0..1, 0..@n).inverse.many_to_one?
+  end
+
+  # Cardinality order ========================================================
+  test "cardinalities should be sorted in order of maniness" do
+    card1 = Relationship::Cardinality.new(0..1, 1)
+    card2 = Relationship::Cardinality.new(1, 1)
+    card3 = Relationship::Cardinality.new(0..1, 1..3)
+    card4 = Relationship::Cardinality.new(1, 1..2)
+    card5 = Relationship::Cardinality.new(1, 1..@n)
+    card6 = Relationship::Cardinality.new(1..5, 1..3)
+    card7 = Relationship::Cardinality.new(1..2, 1..15)
+    card8 = Relationship::Cardinality.new(1..15, 1..@n)
+    card9 = Relationship::Cardinality.new(1..@n, 1..@n)
+    assert_equal [card1, card2, card3, card4, card5, card6, card7, card8, card9],
+      [card9, card5, card8, card2, card4, card7, card1, card6, card3].sort
   end
 end

data/test/unit/diagram_test.rb

@@ -9,6 +9,42 @@ class DiagramTest < ActiveSupport::TestCase
     RailsERD.send :remove_const, :Diagram
   end
   
+  def retrieve_relationships(options = {})
+    klass = Class.new(Diagram)
+    [].tap do |relationships|
+      klass.class_eval do
+        define_method :process_relationship do |relationship|
+          relationships << relationship
+        end
+      end
+      klass.create(options)
+    end
+  end
+
+  def retrieve_entities(options = {})
+    klass = Class.new(Diagram)
+    [].tap do |entities|
+      klass.class_eval do
+        define_method :process_entity do |entity, attributes|
+          entities << entity
+        end
+      end
+      klass.create(options)
+    end
+  end
+  
+  def retrieve_attribute_lists(options = {})
+    klass = Class.new(Diagram)
+    {}.tap do |attribute_lists|
+      klass.class_eval do
+        define_method :process_entity do |entity, attributes|
+          attribute_lists[entity.model] = attributes
+        end
+      end
+      klass.create(options)
+    end
+  end
+  
   # Diagram ==================================================================
   test "create class method should return result of save" do
     create_simple_domain
@@ -54,4 +90,138 @@ class DiagramTest < ActiveSupport::TestCase
       end.create
     end
   end
+  
+  # Entity filtering =========================================================
+  test "generate should yield entities" do
+    create_model "Foo"
+    assert_equal [Foo], retrieve_entities.map(&:model)
+  end
+
+  test "generate should filter disconnected entities if disconnected is false" do
+    create_model "Book", :author => :references do
+      belongs_to :author
+    end
+    create_model "Author"
+    create_model "Table", :type => :string
+    assert_equal [Author, Book], retrieve_entities(:disconnected => false).map(&:model)
+  end
+
+  test "generate should yield disconnected entities if disconnected is true" do
+    create_model "Foo", :type => :string
+    assert_equal [Foo], retrieve_entities(:disconnected => true).map(&:model)
+  end
+
+  test "generate should filter descendant entities" do
+    create_model "Foo", :type => :string
+    Object.const_set :SpecialFoo, Class.new(Foo)
+    assert_equal [Foo], retrieve_entities.map(&:model)
+  end
+  
+  test "generate should yield descended entities with distinct tables" do
+    create_model "Foo"
+    Object.const_set :SpecialFoo, Class.new(Foo)
+    SpecialFoo.class_eval do
+      set_table_name "special_foo"
+    end
+    create_table "special_foo", {}, true
+    assert_equal [Foo, SpecialFoo], retrieve_entities.map(&:model)
+  end
+  
+  # Relationship filtering ===================================================
+  test "generate should yield relationships" do
+    create_simple_domain
+    assert_equal 1, retrieve_relationships.length
+  end
+
+  test "generate should yield indirect relationships if indirect is true" do
+    create_model "Foo" do
+      has_many :bazs
+      has_many :bars
+    end
+    create_model "Bar", :foo => :references do
+      belongs_to :foo
+      has_many :bazs, :through => :foo
+    end
+    create_model "Baz", :foo => :references do
+      belongs_to :foo
+    end
+    assert_equal [false, false, true], retrieve_relationships(:indirect => true).map(&:indirect?)
+  end
+  
+  test "generate should filter indirect relationships if indirect is false" do
+    create_model "Foo" do
+      has_many :bazs
+      has_many :bars
+    end
+    create_model "Bar", :foo => :references do
+      belongs_to :foo
+      has_many :bazs, :through => :foo
+    end
+    create_model "Baz", :foo => :references do
+      belongs_to :foo
+    end
+    assert_equal [false, false], retrieve_relationships(:indirect => false).map(&:indirect?)
+  end
+
+  test "generate should filter relationships from descendant entities" do
+    create_model "Foo", :bar => :references
+    create_model "Bar", :type => :string
+    Object.const_set :SpecialBar, Class.new(Bar)
+    SpecialBar.class_eval do
+      has_many :foos
+    end
+    assert_equal [], retrieve_relationships
+  end
+  
+  test "generate should filter relationships to descendant entities" do
+    create_model "Foo", :type => :string, :bar => :references
+    Object.const_set :SpecialFoo, Class.new(Foo)
+    create_model "Bar" do
+      has_many :special_foos
+    end
+    assert_equal [], retrieve_relationships
+  end
+
+  # Attribute filtering ======================================================
+  test "generate should yield regular attributes by default" do
+    create_model "Book", :title => :string, :created_at => :datetime, :author => :references do
+      belongs_to :author
+    end
+    create_model "Author"
+    assert_equal %w{title}, retrieve_attribute_lists[Book].map(&:name)
+  end
+
+  test "generate should yield primary key attributes if included" do
+    create_model "Book", :title => :string
+    create_model "Page", :book => :references do
+      belongs_to :book
+    end
+    assert_equal %w{id}, retrieve_attribute_lists(:attributes => [:primary_keys])[Book].map(&:name)
+  end
+
+  test "generate should yield foreign key attributes if included" do
+    create_model "Book", :author => :references do
+      belongs_to :author
+    end
+    create_model "Author"
+    assert_equal %w{author_id}, retrieve_attribute_lists(:attributes => [:foreign_keys])[Book].map(&:name)
+  end
+
+  test "generate should yield timestamp attributes if included" do
+    create_model "Book", :created_at => :datetime, :created_on => :date, :updated_at => :datetime, :updated_on => :date
+    create_model "Page", :book => :references do
+      belongs_to :book
+    end
+    assert_equal %w{created_at created_on updated_at updated_on},
+      retrieve_attribute_lists(:attributes => [:timestamps])[Book].map(&:name)
+  end
+
+  test "generate should yield combinations of attributes if included" do
+    create_model "Book", :created_at => :datetime, :title => :string, :author => :references do
+      belongs_to :author
+    end
+    create_model "Author"
+    assert_equal %w{created_at title},
+      retrieve_attribute_lists(:attributes => [:regular, :timestamps])[Book].map(&:name)
+  end
 end

data/test/unit/domain_test.rb

@@ -28,7 +28,7 @@ class DomainTest < ActiveSupport::TestCase
       belongs_to :bar
     end
     create_model "Bar"
-    assert_match %r{#<RailsERD::Domain:.* {Bar => Foo}>}, Domain.generate.inspect
+    assert_match %r{#<RailsERD::Domain:.* \{Bar => Foo\}>}, Domain.generate.inspect
   end
   
   # Entity processing ========================================================
@@ -89,14 +89,14 @@ class DomainTest < ActiveSupport::TestCase
     create_model "Foo" do
       has_many :flabs
     end
-    assert_equal [], Domain.generate(:suppress_warnings => true).relationships
+    assert_equal [], Domain.generate(:warn => false).relationships
   end
   
   test "relationships should omit bad has_many through association" do
     create_model "Foo" do
       has_many :flabs, :through => :bars
     end
-    assert_equal [], Domain.generate(:suppress_warnings => true).relationships
+    assert_equal [], Domain.generate(:warn => false).relationships
   end
   
   test "relationships should omit association to model outside domain" do
@@ -104,7 +104,7 @@ class DomainTest < ActiveSupport::TestCase
       has_many :bars
     end
     create_model "Bar", :foo => :references
-    assert_equal [], Domain.new([Foo], :suppress_warnings => true).relationships
+    assert_equal [], Domain.new([Foo], :warn => false).relationships
   end
 
   test "relationships should output a warning when a bad association is encountered" do
@@ -114,7 +114,7 @@ class DomainTest < ActiveSupport::TestCase
     output = collect_stdout do
       Domain.generate.relationships
     end
-    assert_match /Invalid association :flabs on Foo/, output
+    assert_match /Ignoring invalid association :flabs on Foo/, output
   end
 
   test "relationships should output a warning when an association to model outside domain is encountered" do
@@ -125,15 +125,15 @@ class DomainTest < ActiveSupport::TestCase
     output = collect_stdout do
       Domain.new([Foo]).relationships
     end
-    assert_match /model Bar exists, but is not included in the domain/, output
+    assert_match /model Bar exists, but is not included in domain/, output
   end
 
-  test "relationships should suppress warnings when a bad association is encountered if warning suppression is enabled" do
+  test "relationships should not warn when a bad association is encountered if warnings are disabled" do
     create_model "Foo" do
       has_many :flabs
     end
     output = collect_stdout do
-      Domain.generate(:suppress_warnings => true).relationships
+      Domain.generate(:warn => false).relationships
     end
     assert_equal "", output
   end

data/test/unit/entity_test.rb

@@ -54,7 +54,37 @@ class EntityTest < ActiveSupport::TestCase
     foo = domain.entity_for(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
+
   # Entity properties ========================================================
   test "connected should return false for unconnected entities" do
     create_models "Foo", "Bar"
@@ -68,6 +98,47 @@ class EntityTest < ActiveSupport::TestCase
     create_model "Bar"
     assert_equal [true, true], Domain.generate.entities.map(&:connected?)
   end
+
+  test "disconnected should return true for unconnected entities" do
+    create_models "Foo", "Bar"
+    assert_equal [true, true], Domain.generate.entities.map(&:disconnected?)
+  end
+
+  test "disconnected should return false for connected entities" do
+    create_model "Foo", :bar => :references do
+      belongs_to :bar
+    end
+    create_model "Bar"
+    assert_equal [false, false], Domain.generate.entities.map(&:disconnected?)
+  end
+  
+  test "descendant should return false for regular entities" do
+    create_model "Foo"
+    assert_equal false, Entity.new(Domain.new, Foo).descendant?
+  end
+
+  test "descendant should return false 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_equal false, Entity.new(Domain.new, SpecialFoo).descendant?
+  end
+
+  test "descendant should return true for child entities" do
+    create_model "Foo", :type => :string
+    Object.const_set :SpecialFoo, Class.new(Foo)
+    assert_equal true, Entity.new(Domain.new, SpecialFoo).descendant?
+  end
+
+  test "descendant should return true 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)
+    assert_equal true, Entity.new(Domain.new, VerySpecialFoo).descendant?
+  end
   
   # Attribute processing =====================================================
   test "attributes should return list of attributes" do