mongoid-ancestry 0.1.0

data/spec/mongoid/ancestry/instance_methods_spec.rb

@@ -0,0 +1,266 @@
+require 'spec_helper'
+
+describe MongoidAncestry do
+
+  subject { MongoidAncestry }
+
+  it "should be saved with unique id for new records" do
+    subject.with_model do |model|
+      new_record = model.create!
+      new_record.uid.should eql(1)
+      expect { new_record.save }.to_not change(new_record, :uid)
+      expect { new_record.save! }.to_not change(new_record, :uid)
+      model.create.uid.should eql(2)
+      model.create!.uid.should eql(3)
+    end
+  end
+
+  it "should raise error on non unique id" do
+    subject.with_model do |model|
+      model.create_indexes
+      expect do
+        first_record = model.new
+        first_record.stub!(:set_uid => true)
+        first_record.save
+        second = model.new
+        second.should_receive(:set_uid).exactly(3).times.and_return(true)
+        second.save
+      end.to raise_error(Mongo::OperationFailure, /duplicate key error/)
+    end
+  end
+
+  it "should have tree navigation" do
+    subject.with_model :depth => 3, :width => 3 do |model, roots|
+      roots.each do |lvl0_node, lvl0_children|
+        # Ancestors assertions
+        lvl0_node.ancestor_ids.should eql([])
+        lvl0_node.ancestors.to_a.should eql([])
+        lvl0_node.path_ids.should eql([lvl0_node.uid])
+        lvl0_node.path.to_a.should eql([lvl0_node])
+        lvl0_node.depth.should eql(0)
+        # Parent assertions
+        lvl0_node.parent_id.should be_nil
+        lvl0_node.parent.should be_nil
+        # Root assertions
+        lvl0_node.root_id.should eql(lvl0_node.uid)
+        lvl0_node.root.should eql(lvl0_node)
+        lvl0_node.is_root?.should be_true
+        # Children assertions
+        lvl0_node.child_ids.should eql(lvl0_children.map(&:first).map(&:uid))
+        lvl0_node.children.to_a.should eql(lvl0_children.map(&:first))
+        lvl0_node.has_children?.should be_true
+        lvl0_node.is_childless?.should be_false
+        # Siblings assertions
+        lvl0_node.sibling_ids.should eql(roots.map(&:first).map(&:uid))
+        lvl0_node.siblings.to_a.should eql(roots.map(&:first))
+        lvl0_node.has_siblings?.should be_true
+        lvl0_node.is_only_child?.should be_false
+        # Descendants assertions
+        descendants = model.all.find_all do |node|
+          node.ancestor_ids.include?(lvl0_node.uid)
+        end
+        lvl0_node.descendant_ids.should eql(descendants.map(&:uid))
+        lvl0_node.descendants.to_a.should eql(descendants)
+        lvl0_node.subtree.to_a.should eql([lvl0_node] + descendants)
+
+        lvl0_children.each do |lvl1_node, lvl1_children|
+          # Ancestors assertions
+          lvl1_node.ancestor_ids.should eql([lvl0_node.uid])
+          lvl1_node.ancestors.to_a.should eql([lvl0_node])
+          lvl1_node.path_ids.should eql([lvl0_node.uid, lvl1_node.uid])
+          lvl1_node.path.to_a.should eql([lvl0_node, lvl1_node])
+          lvl1_node.depth.should eql(1)
+          # Parent assertions
+          lvl1_node.parent_id.should eql(lvl0_node.uid)
+          lvl1_node.parent.should eql(lvl0_node)
+          # Root assertions
+          lvl1_node.root_id.should eql(lvl0_node.uid)
+          lvl1_node.root.should eql(lvl0_node)
+          lvl1_node.is_root?.should be_false
+          # Children assertions
+          lvl1_node.child_ids.should eql(lvl1_children.map(&:first).map(&:uid))
+          lvl1_node.children.to_a.should eql(lvl1_children.map(&:first))
+          lvl1_node.has_children?.should be_true
+          lvl1_node.is_childless?.should be_false
+          # Siblings assertions
+          lvl1_node.sibling_ids.should eql(lvl0_children.map(&:first).map(&:uid))
+          lvl1_node.siblings.to_a.should eql(lvl0_children.map(&:first))
+          lvl1_node.has_siblings?.should be_true
+          lvl1_node.is_only_child?.should be_false
+          # Descendants assertions
+          descendants = model.all.find_all do |node|
+            node.ancestor_ids.include? lvl1_node.uid
+          end
+
+          lvl1_node.descendant_ids.should eql(descendants.map(&:uid))
+          lvl1_node.descendants.to_a.should eql(descendants)
+          lvl1_node.subtree.to_a.should eql([lvl1_node] + descendants)
+
+          lvl1_children.each do |lvl2_node, lvl2_children|
+            # Ancestors assertions
+            lvl2_node.ancestor_ids.should eql([lvl0_node.uid, lvl1_node.uid])
+            lvl2_node.ancestors.to_a.should eql([lvl0_node, lvl1_node])
+            lvl2_node.path_ids.should eql([lvl0_node.uid, lvl1_node.uid, lvl2_node.uid])
+            lvl2_node.path.to_a.should eql([lvl0_node, lvl1_node, lvl2_node])
+            lvl2_node.depth.should eql(2)
+            # Parent assertions
+            lvl2_node.parent_id.should eql(lvl1_node.uid)
+            lvl2_node.parent.should eql(lvl1_node)
+            # Root assertions
+            lvl2_node.root_id.should eql(lvl0_node.uid)
+            lvl2_node.root.should eql(lvl0_node)
+            lvl2_node.is_root?.should be_false
+            # Children assertions
+            lvl2_node.child_ids.should eql([])
+            lvl2_node.children.to_a.should eql([])
+            lvl2_node.has_children?.should be_false
+            lvl2_node.is_childless?.should be_true
+            # Siblings assertions
+            lvl2_node.sibling_ids.should eql(lvl1_children.map(&:first).map(&:uid))
+            lvl2_node.siblings.to_a.should eql(lvl1_children.map(&:first))
+            lvl2_node.has_siblings?.should be_true
+            lvl2_node.is_only_child?.should be_false
+            # Descendants assertions
+            descendants = model.all.find_all do |node|
+              node.ancestor_ids.include? lvl2_node.id
+            end
+            lvl2_node.descendant_ids.should eql(descendants.map(&:uid))
+            lvl2_node.descendants.to_a.should eql(descendants)
+            lvl2_node.subtree.to_a.should eql([lvl2_node] + descendants)
+          end
+        end
+      end
+    end
+  end
+
+  it "should validate ancestry field" do
+    subject.with_model do |model|
+      node = model.create
+      ['3', '10/2', '1/4/30', nil].each do |value|
+        node.send :write_attribute, model.ancestry_field, value
+        node.valid?
+        node.errors[model.ancestry_field].blank?.should be_true
+      end
+      ['1/3/', '/2/3', 'a', 'a/b', '-34', '/54'].each do |value|
+        node.send :write_attribute, model.ancestry_field, value
+        node.valid?
+        node.errors[model.ancestry_field].blank?.should be_false
+      end
+    end
+  end
+
+  it "should move descendants with node" do
+    subject.with_model :depth => 3, :width => 3 do |model, roots|
+      root1, root2, root3 = roots.map(&:first)
+
+      descendants = root1.descendants.asc(:uid).to_a
+      expect {
+        root1.parent = root2
+        root1.save!
+        root1.descendants.asc(:uid).to_a.should eql(descendants)
+      }.to change(root2.descendants, 'size').by(root1.subtree.size)
+
+      descendants = root2.descendants.asc(:uid).to_a
+      expect {
+        root2.parent = root3
+        root2.save!
+        root2.descendants.asc(:uid).to_a.should eql(descendants)
+      }.to change(root3.descendants, 'size').by(root2.subtree.size)
+
+      descendants = root1.descendants.asc(:uid).to_a
+      expect {
+        expect {
+          root1.parent = nil
+          root1.save!
+          root1.descendants.asc(:uid).to_a.should eql(descendants)
+        }.to change(root3.descendants, 'size').by(-root1.subtree.size)
+      }.to change(root2.descendants, 'size').by(-root1.subtree.size)
+    end
+  end
+
+  it "should validate ancestry exclude self" do
+    subject.with_model do |model|
+      parent = model.create!
+      child = parent.children.create
+      expect { parent.update_attributes! :parent => child }.to raise_error(Mongoid::Errors::Validations)
+    end
+  end
+
+  it "should have depth caching" do 
+    subject.with_model :depth => 3, :width => 3, :cache_depth => true, :depth_cache_field => :depth_cache do |model, roots|
+      roots.each do |lvl0_node, lvl0_children|
+        lvl0_node.depth_cache.should eql(0)
+        lvl0_children.each do |lvl1_node, lvl1_children|
+          lvl1_node.depth_cache.should eql(1)
+          lvl1_children.each do |lvl2_node, lvl2_children|
+            lvl2_node.depth_cache.should eql(2)
+          end
+        end
+      end
+    end
+  end
+
+  it "should have descendants with depth constraints" do
+    subject.with_model :depth => 4, :width => 4, :cache_depth => true do |model, roots|
+      model.roots.first.descendants(:before_depth => 2).count.should eql(4)
+      model.roots.first.descendants(:to_depth => 2).count.should eql(20)
+      model.roots.first.descendants(:at_depth => 2).count.should eql(16)
+      model.roots.first.descendants(:from_depth => 2).count.should eql(80)
+      model.roots.first.descendants(:after_depth => 2).count.should eql(64)
+    end
+  end
+
+  it "should have subtree with depth constraints" do
+    subject.with_model :depth => 4, :width => 4, :cache_depth => true do |model, roots|
+      model.roots.first.subtree(:before_depth => 2).count.should eql(5)
+      model.roots.first.subtree(:to_depth => 2).count.should eql(21)
+      model.roots.first.subtree(:at_depth => 2).count.should eql(16)
+      model.roots.first.subtree(:from_depth => 2).count.should eql(80)
+      model.roots.first.subtree(:after_depth => 2).count.should eql(64)
+    end
+  end
+
+  it "should have ancestors with depth constraints" do
+    subject.with_model :cache_depth => true do |model|
+      node1 = model.create!
+      node2 = node1.children.create
+      node3 = node2.children.create
+      node4 = node3.children.create
+      node5 = node4.children.create
+      leaf  = node5.children.create
+
+      leaf.ancestors(:before_depth => -2).to_a.should eql([node1, node2, node3])
+      leaf.ancestors(:to_depth => -2).to_a.should eql([node1, node2, node3, node4])
+      leaf.ancestors(:at_depth => -2).to_a.should eql([node4])
+      leaf.ancestors(:from_depth => -2).to_a.should eql([node4, node5])
+      leaf.ancestors(:after_depth => -2).to_a.should eql([node5])
+    end
+  end
+
+  it "should have path with depth constraints" do
+    subject.with_model :cache_depth => true do |model|
+      node1 = model.create!
+      node2 = node1.children.create
+      node3 = node2.children.create
+      node4 = node3.children.create
+      node5 = node4.children.create
+      leaf  = node5.children.create
+
+      leaf.path(:before_depth => -2).to_a.should eql([node1, node2, node3])
+      leaf.path(:to_depth => -2).to_a.should eql([node1, node2, node3, node4])
+      leaf.path(:at_depth => -2).to_a.should eql([node4])
+      leaf.path(:from_depth => -2).to_a.should eql([node4, node5, leaf])
+      leaf.path(:after_depth => -2).to_a.should eql([node5, leaf])
+    end
+  end
+
+  it "should raise exception on unknown depth field" do
+    subject.with_model :cache_depth => true do |model|
+      expect {
+        model.create!.subtree(:this_is_not_a_valid_depth_option => 42)
+      }.to raise_error(Mongoid::Ancestry::Error)
+    end
+  end
+
+
+end

data/spec/mongoid/ancestry_spec.rb

@@ -0,0 +1,117 @@
+require 'spec_helper'
+
+require 'mongoid/ancestry/exceptions'
+
+
+describe MongoidAncestry do
+
+  subject { MongoidAncestry }
+
+  it "should have ancestry fields" do
+    subject.with_model do |model|
+      model.fields['ancestry'].options[:type].should eql(String)
+      model.fields['uid'].options[:type].should eql(Integer)
+    end
+  end
+
+  it "should have ancestry indexes" do
+    subject.with_model do |model|
+      model.index_options.should have_key(:uid)
+    end
+  end
+
+  it "should have non default ancestry field" do
+    subject.with_model :ancestry_field => :alternative_ancestry do |model|
+      model.ancestry_field.should eql(:alternative_ancestry)
+    end
+  end
+
+  it "should set ancestry field" do
+    subject.with_model do |model|
+      model.ancestry_field = :ancestors
+      model.ancestry_field.should eql(:ancestors)
+      model.ancestry_field = :ancestry
+      model.ancestry_field.should eql(:ancestry)
+    end
+  end
+
+  it "should have default orphan strategy" do
+    subject.with_model do |model|
+      model.orphan_strategy.should eql(:destroy)
+    end
+  end
+
+  it "should have non default orphan strategy" do
+    subject.with_model :orphan_strategy => :rootify do |model|
+      model.orphan_strategy.should eql(:rootify)
+    end
+  end
+
+  it "should set orphan strategy" do
+    subject.with_model do |model|
+      model.orphan_strategy = :rootify
+      model.orphan_strategy.should eql(:rootify)
+      model.orphan_strategy = :destroy
+      model.orphan_strategy.should eql(:destroy)
+    end
+  end
+
+  it "should not set invalid orphan strategy" do
+    subject.with_model do |model|
+      expect {
+        model.orphan_strategy = :non_existent_orphan_strategy
+      }.to raise_error Mongoid::Ancestry::Error
+    end
+  end
+
+  it "should setup test nodes" do
+    subject.with_model :depth => 3, :width => 3 do |model, roots|
+      roots.class.should eql(Array)
+      roots.length.should eql(3)
+      roots.each do |node, children|
+        node.class.should eql(model)
+        children.class.should eql(Array)
+        children.length.should eql(3)
+        children.each do |node, children|
+          node.class.should eql(model)
+          children.class.should eql(Array)
+          children.length.should eql(3)
+          children.each do |node, children|
+            node.class.should eql(model)
+            children.class.should eql(Array)
+            children.length.should eql(0)
+          end
+        end
+      end
+    end
+  end
+
+  it "should have STI support" do
+    subject.with_model :extra_columns => {:type => :string} do |model|
+      subclass1 = Object.const_set 'Subclass1', Class.new(model)
+      (class << subclass1; self; end).send(:define_method, :model_name) do
+      Struct.new(:human, :underscore).new 'Subclass1', 'subclass1'
+      end
+      subclass2 = Object.const_set 'Subclass2', Class.new(model)
+      (class << subclass2; self; end).send(:define_method, :model_name) do
+      Struct.new(:human, :underscore).new 'Subclass1', 'subclass1'
+      end
+
+      node1 = subclass1.create
+      node2 = subclass2.create :parent => node1
+      node3 = subclass1.create :parent => node2
+      node4 = subclass2.create :parent => node3
+      node5 = subclass1.create :parent => node4
+
+      model.all.each do |node|
+        [subclass1, subclass2].include?(node.class).should be_true
+      end
+
+      node1.descendants.map(&:id).should eql([node2.id, node3.id, node4.id, node5.id])
+      node1.subtree.map(&:id).should eql([node1.id, node2.id, node3.id, node4.id, node5.id])
+      node5.ancestors.map(&:id).should eql([node1.id, node2.id, node3.id, node4.id])
+      node5.path.map(&:id).should eql([node1.id, node2.id, node3.id, node4.id, node5.id])
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,20 @@
+require 'rubygems'
+require 'bundler/setup'
+
+require 'mongoid'
+require 'rspec'
+
+Mongoid.configure do |config|
+  logger = Logger.new('log/test.log')
+  config.master = Mongo::Connection.new('localhost', 27017,
+    :logger => logger).db('ancestry_test')
+  config.logger = logger
+end
+
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+  config.after :each do
+    Mongoid.master.collections.reject { |c| c.name =~ /^system\./ }.each(&:drop)
+  end
+end

data/spec/support/models.rb

@@ -0,0 +1,44 @@
+require 'mongoid/ancestry'
+
+
+class MongoidAncestry
+
+  def self.with_model options = {}
+    depth         = options.delete(:depth) || 0
+    width         = options.delete(:width) || 0
+    extra_columns = options.delete(:extra_columns)
+    skip_ancestry = options.delete(:skip_ancestry)
+
+    begin
+      model = Class.new
+      (class << model; self; end).send :define_method, :model_name do; Struct.new(:human, :underscore, :i18n_key).new 'TestNode', 'test_node', 'key'; end
+      const_set 'TestNode', model
+      TestNode.send(:include, Mongoid::Document)
+      TestNode.send(:include, Mongoid::Ancestry) unless skip_ancestry
+
+      extra_columns.each do |name, type|
+        TestNode.send :field, name, :type => type.to_s.capitalize.constantize
+      end unless extra_columns.nil?
+
+      TestNode.has_ancestry options unless skip_ancestry
+
+      if depth > 0
+        yield TestNode, create_test_nodes(TestNode, depth, width)
+      else
+        yield TestNode
+      end
+    ensure
+      #Mongoid.master.collections.reject { |c| c.name =~ /^system\./ }.each(&:drop)
+      remove_const "TestNode"
+    end
+  end
+
+  def self.create_test_nodes model, depth, width, parent = nil
+    unless depth == 0
+      Array.new width do
+        node = model.create!(:parent => parent)
+        [node, create_test_nodes(model, depth - 1, width, node)]
+      end
+    else; []; end
+  end
+end