dagnabit 2.2.1

data/test/dagnabit/link/test_validations.rb

@@ -0,0 +1,39 @@
+require 'helper'
+
+module Dagnabit
+  module Link
+    class TestValidations < ActiveRecord::TestCase
+      def setup
+        @n1 = ::Node.new
+        @n2 = ::Node.new
+        @link = ::Link.new
+      end
+
+      should 'not permit a null ancestor' do
+        @link.ancestor = nil
+        assert !@link.save
+      end
+
+      should 'not permit an invalid ancestor' do
+        @n1.stubs(:valid?).returns(false)
+
+        @link.ancestor = @n1
+        @link.descendant = @n2
+        assert !@link.save
+      end
+
+      should 'not permit a null descendant' do
+        @link.descendant = nil
+        assert !@link.save
+      end
+
+      should 'not permit an invalid descendant' do
+        @n2.stubs(:valid?).returns(false)
+
+        @link.ancestor = @n1
+        @link.descendant = @n2
+        assert !@link.save
+      end
+    end
+  end
+end

data/test/dagnabit/node/test_associations.rb

@@ -0,0 +1,147 @@
+require 'helper'
+
+module Dagnabit
+  module Node
+    class TestAssociations < ActiveRecord::TestCase
+      class OtherLink < ActiveRecord::Base
+        set_table_name 'edges'
+        acts_as_dag_link
+      end
+
+      class OtherNode < ActiveRecord::Base
+        set_table_name 'nodes'
+        acts_as_dag_node_linked_by 'Dagnabit::Node::TestAssociations::OtherLink'
+      end
+
+      class BaseNode < ActiveRecord::Base
+        self.abstract_class = true
+        set_table_name 'nodes'
+        acts_as_dag_node_linked_by '::Link'
+      end
+
+      class DerivedNode < BaseNode
+      end
+
+      def setup
+        @n1 = ::Node.new
+        @n2 = ::Node.new
+        @n3 = ::Node.new
+      end
+
+      should 'report links for which the node is a child' do
+        ::Link.connect(@n1, @n2)
+
+        assert_equal 1, @n2.links_as_child.count
+        assert_equal @n1, @n2.links_as_child.first.ancestor
+      end
+
+      should 'report links for which the node is a child, using a different link model' do
+        n1 = OtherNode.new
+        n2 = OtherNode.new
+
+        OtherLink.connect(n1, n2)
+
+        assert_equal 1, n2.links_as_child.count
+        assert_equal n1, n2.links_as_child.first.ancestor
+
+        assert n2.links_as_child.first.is_a?(OtherLink), 'expected OtherLink'
+      end
+
+      should 'report links for which the node is a child, using a different link model and different foreign key' do
+        n1 = CustomizedLinkNode.new
+        n2 = CustomizedLinkNode.new
+
+        CustomizedLink.connect(n1, n2)
+
+        assert_equal 1, n2.links_as_child.count
+        assert_equal n1, n2.links_as_child.first.ancestor
+
+        assert n2.links_as_child.first.is_a?(CustomizedLink), 'expected CustomizedLink'
+      end
+
+      should 'report links for which the node is a parent' do
+        ::Link.connect(@n1, @n2)
+
+        assert_equal 1, @n1.links_as_parent.count
+        assert_equal @n2, @n1.links_as_parent.first.descendant
+      end
+
+      should 'report links for which the node is an ancestor' do
+        ::Link.connect(@n1, @n2)
+        ::Link.connect(@n1, @n3)
+
+        assert_equal 2, @n1.links_as_ancestor.count
+        assert_equal Set.new([@n2, @n3]), Set.new(@n1.links_as_ancestor.map(&:descendant))
+      end
+
+      should 'report links for which the node is a descendant' do
+        ::Link.connect(@n1, @n2)
+        ::Link.connect(@n2, @n3)
+
+        assert_equal 2, @n3.links_as_descendant.count
+        assert_equal Set.new([@n1, @n2]), Set.new(@n3.links_as_descendant.map(&:ancestor))
+      end
+
+      should 'clean up links to parents and children when destroyed' do
+        n1 = ::Node.new
+        n2 = ::Node.new
+        n3 = ::Node.new
+
+        ::Link.connect(n1, n2)
+        ::Link.connect(n2, n3)
+        ::Link.connect(n1, n3)
+
+        n2.destroy
+
+        assert_equal [n3], n1.children
+        assert_equal [n3], n1.descendants
+        assert_equal [n1], n3.ancestors
+        assert_equal [n1], n3.parents
+      end
+
+      should 'report links for which the node is a parent on derived nodes' do
+        n1 = DerivedNode.new
+        n2 = DerivedNode.new
+
+        ::Link.connect(n1, n2)
+
+        assert_equal [n2], n1.links_as_parent.map(&:descendant)
+      end
+
+      context 'node class scoping' do
+        setup do
+          @n1 = ::Node.new
+          @n2a = ::BetaNode.new
+          @n2b = ::BetaNode.new
+          @n3 = ::Node.new
+
+          ::Link.connect(@n1, @n2a)
+          ::Link.connect(@n1, @n2b)
+          ::Link.connect(@n2a, @n3)
+          ::Link.connect(@n2b, @n3)
+        end
+
+        should 'apply to parent links' do
+          assert_equal 2, @n1.links_as_parent.length
+        end
+
+        should 'apply to child links' do
+          assert_equal 2, @n3.links_as_child.length
+        end
+
+        should 'apply to ancestor links' do
+          # We expect three links here:
+          # n1 -> n2a
+          # n1 -> n2b
+          # n1 -> n3
+          assert_equal 3, @n1.links_as_ancestor.length
+        end
+
+        should 'apply to descendant links' do
+          # Similar logic here.
+          assert_equal 3, @n3.links_as_descendant.length
+        end
+      end
+    end
+  end
+end

data/test/dagnabit/node/test_class_methods.rb

@@ -0,0 +1,49 @@
+require 'helper'
+
+module Dagnabit
+  module Node
+    class TestClassMethods < ActiveRecord::TestCase
+      def setup
+        #
+        # Structure:
+        #
+        #    -- n1 
+        #   /      \
+        # n0        n3 -- n4
+        #   \-- n2 /
+        #
+        @links = []
+        @ns = (1..5).map { ::Node.new }
+
+        [ [@ns[0], @ns[1]],
+          [@ns[0], @ns[2]],
+          [@ns[1], @ns[3]],
+          [@ns[2], @ns[3]],
+          [@ns[3], @ns[4]] ].each do |ancestor, descendant|
+            @links << ::Link.new(:ancestor => ancestor, :descendant => descendant)
+          end
+
+        @ns.each { |n| n.save }
+        @links.each { |l| l.save }
+        @root = @ns[0]
+      end
+
+      should 'allow retrieval of subgraphs rooted at a given node' do
+        graph = ::Node.subgraph_from(@root)
+
+        assert_equal Set.new(@ns), graph.nodes
+        assert_equal Set.new(@links), graph.edges
+      end
+
+      should 'allow retrieval of subgraphs rooted at multiple nodes' do
+        graph = ::Node.subgraph_from(@ns[1], @ns[2])
+
+        # expect n0 to not be present
+        assert_equal Set.new(@ns[1..4]), graph.nodes
+
+        # expect (n0, n1) and (n0, n2) to not be present
+        assert_equal Set.new(@links[2..-1]), graph.edges
+      end
+    end
+  end
+end

data/test/dagnabit/node/test_configuration.rb

@@ -0,0 +1,29 @@
+require 'helper'
+
+module Dagnabit
+  module Node
+    class TestConfiguration < ActiveRecord::TestCase
+      def setup
+        @node_model = Class.new(ActiveRecord::Base) do
+          set_table_name 'nodes'
+
+          extend Dagnabit::Node::Configuration
+        end
+      end
+
+      should 'accept the name of a link class' do
+        @node_model.configure_acts_as_dag_node('Link')
+
+        assert_equal 'Link', @node_model.link_class_name
+      end
+
+      should 'be inheritable' do
+        @node_model.configure_acts_as_dag_node('Link')
+
+        subclassed_model = Class.new(@node_model)
+
+        assert_equal 'Link', subclassed_model.link_class_name
+      end
+    end
+  end
+end

data/test/dagnabit/node/test_neighbors.rb

@@ -0,0 +1,91 @@
+require 'helper'
+
+module Dagnabit
+  module Node
+    class TestNeighbors < ActiveRecord::TestCase
+      class OtherNode < ActiveRecord::Base
+        set_table_name 'nodes'
+        acts_as_dag_node_linked_by '::Link'
+      end
+
+      def setup
+        @n1 = ::Node.new
+        @n2 = OtherNode.new
+        @n3 = ::Node.new
+
+        ::Link.connect(@n1, @n2)
+        ::Link.connect(@n2, @n3)
+      end
+
+      should 'return all ancestors' do
+        ancestors = @n3.ancestors
+        assert_equal 2, ancestors.length
+        assert_equal Set.new([@n1, @n2]), Set.new(ancestors)
+      end
+
+      should 'return all ancestors of a specified type' do
+        ancestors = @n3.ancestors_of_type(OtherNode.name)
+        assert_equal [@n2], ancestors
+      end
+
+      should 'return all descendants' do
+        descendants = @n1.descendants
+        assert_equal 2, descendants.length
+        assert_equal Set.new([@n2, @n3]), Set.new(descendants)
+      end
+
+      should 'return all descendants of a specified type' do
+        descendants = @n1.descendants_of_type(OtherNode.name)
+        assert_equal [@n2], descendants
+      end
+
+      should 'return all children' do
+        assert_equal [@n2], @n1.children
+      end
+
+      should 'return all children of a specified type' do
+        assert_equal [@n2], @n1.children_of_type(OtherNode.name)
+        assert_equal [], @n1.children_of_type(::Node.name)
+      end
+      
+      should 'return all parents' do
+        assert_equal [@n1], @n2.parents
+      end
+
+      should 'return all parents of a specified type' do
+        assert_equal [@n2], @n3.parents_of_type(OtherNode.name)
+        assert_equal [], @n3.parents_of_type(::Node.name)
+      end
+
+      should 'not report ancestor nodes as parent nodes' do
+        assert_equal 1, @n3.parents.length
+      end
+
+      should 'return all ancestors of the specified neighbor types using customized links' do
+        n1 = CustomizedLinkNode.new
+        n2 = CustomizedLinkNode.new
+        n3 = CustomizedLinkNode.new
+
+        CustomizedLink.connect(n1, n2)
+        CustomizedLink.connect(n2, n3)
+
+        ancestors = n3.ancestors
+        assert_equal 2, ancestors.length
+        assert_equal Set.new([n1, n2]), Set.new(ancestors)
+      end
+
+      should 'return all descendants of the specified neighbor types using customized links' do
+        n1 = CustomizedLinkNode.new
+        n2 = CustomizedLinkNode.new
+        n3 = CustomizedLinkNode.new
+
+        CustomizedLink.connect(n1, n2)
+        CustomizedLink.connect(n2, n3)
+
+        descendants = n1.descendants
+        assert_equal 2, descendants.length
+        assert_equal Set.new([n2, n3]), Set.new(descendants)
+      end
+    end
+  end
+end

data/test/helper.rb

@@ -0,0 +1,27 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+require 'mocha'
+require 'active_record'
+require 'active_record/fixtures'
+require 'active_support'
+require 'active_support/whiny_nil'
+require 'connection'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'dagnabit'
+
+SCHEMA_ROOT = File.join(File.dirname(__FILE__), 'schema')
+
+class ActiveSupport::TestCase
+  include ActiveRecord::TestFixtures
+
+  self.use_transactional_fixtures = true
+end
+
+load(SCHEMA_ROOT + '/schema.rb')
+
+# load link models before other models
+models = Dir[File.dirname(__FILE__) + '/models/**/*.rb']
+models.sort { |x, y| x =~ /link\.rb$/ ? -1 : 0 }.each { |m| require m }

data/test/models/beta_node.rb

@@ -0,0 +1,3 @@
+class BetaNode < ActiveRecord::Base
+  acts_as_dag_node_linked_by 'Link'
+end

data/test/models/custom_data_link.rb

@@ -0,0 +1,4 @@
+class CustomDataLink < ActiveRecord::Base
+  set_table_name 'custom_data_edges'
+  acts_as_dag_link
+end

data/test/models/customized_link.rb

@@ -0,0 +1,7 @@
+class CustomizedLink < ActiveRecord::Base
+  set_table_name 'other_name_edges'
+
+  acts_as_dag_link :ancestor_id_column => 'the_ancestor_id',
+                   :descendant_id_column => 'the_descendant_id',
+                   :transitive_closure_table_name => 'my_transitive_closure'
+end

data/test/models/customized_link_node.rb

@@ -0,0 +1,4 @@
+class CustomizedLinkNode < ActiveRecord::Base
+  set_table_name 'nodes'
+  acts_as_dag_node_linked_by '::CustomizedLink'
+end

data/test/models/link.rb

@@ -0,0 +1,4 @@
+class Link < ActiveRecord::Base
+  set_table_name 'edges'
+  acts_as_dag_link
+end

data/test/models/node.rb

@@ -0,0 +1,3 @@
+class Node < ActiveRecord::Base
+  acts_as_dag_node_linked_by 'Link'
+end

data/test/schema/schema.rb

@@ -0,0 +1,51 @@
+ActiveRecord::Schema.define do
+  create_table :edges, :force => true do |t|
+    t.integer :ancestor_id
+    t.integer :descendant_id
+    t.string :ancestor_type
+    t.string :descendant_type
+  end
+
+  create_table :edges_transitive_closure_tuples, :force => true do |t|
+    t.integer :ancestor_id
+    t.integer :descendant_id
+    t.string :ancestor_type
+    t.string :descendant_type
+  end
+
+  create_table :custom_data_edges, :force => true do |t|
+    t.integer :ancestor_id
+    t.integer :descendant_id
+    t.string :ancestor_type
+    t.string :descendant_type
+    t.string :data
+  end
+
+  create_table :custom_data_edges_transitive_closure_tuples, :force => true do |t|
+    t.integer :ancestor_id
+    t.integer :descendant_id
+    t.string :ancestor_type
+    t.string :descendant_type
+    t.string :data
+  end
+
+  create_table :nodes, :force => true do |t|
+  end
+
+  create_table :beta_nodes, :force => true do |t|
+  end
+
+  create_table :other_name_edges, :force => true do |t|
+    t.integer :the_ancestor_id
+    t.integer :the_descendant_id
+    t.string :ancestor_type
+    t.string :descendant_type
+  end
+
+  create_table :my_transitive_closure, :force => true do |t|
+    t.integer :the_ancestor_id
+    t.integer :the_descendant_id
+    t.string :ancestor_type
+    t.string :descendant_type
+  end
+end