jacobat-refinerycms 0.9.6.14

data/vendor/plugins/acts_as_indexed/test/abstract_unit.rb

@@ -0,0 +1,47 @@
+require 'test/unit'
+require 'fileutils'
+require 'rubygems'
+require 'active_record'
+require 'active_record/fixtures'
+require File.dirname(__FILE__) + '/../lib/acts_as_indexed'
+
+# Mock out the required environment variables.
+RAILS_ENV = 'test'
+RAILS_ROOT = Dir.pwd
+
+ActiveRecord::Base.logger = Logger.new(File.dirname(__FILE__) + '/test.log')
+ActiveRecord::Base.configurations = YAML::load(IO.read(File.dirname(__FILE__) + '/database.yml'))
+ActiveRecord::Base.establish_connection(ENV['DB'] || 'sqlite3')
+
+# Load Schema
+load(File.dirname(__FILE__) + '/schema.rb')
+
+# Load model.
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/fixtures/')
+
+class ActiveSupport::TestCase #:nodoc:
+  include ActiveRecord::TestFixtures
+  self.fixture_path = File.dirname(__FILE__) + '/fixtures/'
+  self.use_transactional_fixtures = true
+  self.use_instantiated_fixtures  = false
+
+  def destroy_index
+    FileUtils::rm_rf(index_loc) if File.exists?(index_loc)
+    assert !File.exists?(index_loc)
+    true
+  end
+
+  def build_index
+    # Makes a query to invoke the index build.
+    assert_equal [], Post.find_with_index('badger')
+    assert File.exists?(index_loc)
+    true
+  end
+
+  protected
+
+  def index_loc
+    File.join(RAILS_ROOT,'index')
+  end
+
+end

data/vendor/plugins/acts_as_indexed/test/acts_as_indexed_test.rb

@@ -0,0 +1,102 @@
+require File.dirname(__FILE__) + '/abstract_unit'
+
+class ActsAsIndexedTest < ActiveSupport::TestCase
+  fixtures :posts
+
+  def setup
+    destroy_index
+  end
+
+  def teardown
+    destroy_index
+  end
+
+  def test_adds_to_index
+    original_post_count = Post.count
+    assert_equal [], Post.find_with_index('badger')
+    p = Post.new(:title => 'badger', :body => 'Thousands of them!')
+    assert p.save
+    assert_equal original_post_count+1, Post.count
+    assert_equal [p.id], Post.find_with_index('badger',{},{:ids_only => true})
+  end
+
+  def test_removes_from_index
+    original_post_count = Post.count
+    assert_equal [posts(:wikipedia_article_4).id], Post.find_with_index('album',{},{:ids_only => true})
+    assert Post.find(posts(:wikipedia_article_4).id).destroy
+    assert_equal [], Post.find_with_index('album',{},{:ids_only => true})
+    assert_equal original_post_count-1, Post.count
+  end
+
+  def test_search_returns_posts
+    Post.find_with_index('album').each do |p|
+      assert_equal Post, p.class
+    end
+  end
+
+  def test_search_returns_post_ids
+    Post.find_with_index('album',{},{:ids_only => true}).each do |pid|
+      assert p = Post.find(pid)
+      assert_equal Post, p.class
+    end
+  end
+
+  # After a portion of a record has been removed
+  # the portion removes should no longer be in the index.
+  def test_updates_index
+    p = Post.create(:title => 'A special title', :body => 'foo bar bla bla bla')
+    assert Post.find_with_index('title',{},{:ids_only => true}).include?(p.id)
+    p.update_attributes(:title => 'No longer special')
+    assert !Post.find_with_index('title',{},{:ids_only => true}).include?(p.id)
+  end
+
+  def test_simple_queries
+    assert_equal [5, 6],  Post.find_with_index('ship',{},{:ids_only => true}).sort
+    assert_equal [6],  Post.find_with_index('foo',{},{:ids_only => true})
+    assert_equal [6],  Post.find_with_index('foo ship',{},{:ids_only => true})
+    assert_equal [6],  Post.find_with_index('ship foo',{},{:ids_only => true})
+  end
+
+  def test_negative_queries
+    assert_equal [5, 6],  Post.find_with_index('crane',{},{:ids_only => true}).sort
+    assert_equal [5],  Post.find_with_index('crane -foo',{},{:ids_only => true})
+    assert_equal [5],  Post.find_with_index('-foo crane',{},{:ids_only => true})
+    assert_equal [],  Post.find_with_index('-foo',{},{:ids_only => true}) #Edgecase
+  end
+
+  def test_quoted_queries
+    assert_equal [5],  Post.find_with_index('"crane ship"',{},{:ids_only => true})
+    assert_equal [6],  Post.find_with_index('"crane big"',{},{:ids_only => true})
+    assert_equal [],  Post.find_with_index('foo "crane ship"',{},{:ids_only => true})
+    assert_equal [],  Post.find_with_index('"crane badger"',{},{:ids_only => true})
+  end
+
+  def test_negative_quoted_queries
+    assert_equal [6],  Post.find_with_index('crane -"crane ship"',{},{:ids_only => true})
+    assert_equal [],  Post.find_with_index('-"crane big"',{},{:ids_only => true}) # Edgecase
+  end
+
+  def test_find_options
+    all_results = Post.find_with_index('crane',{},{:ids_only => true})
+    first_result = Post.find_with_index('crane',{:limit => 1})
+
+    assert_equal 1, first_result.size
+    assert_equal all_results.first, first_result.first.id
+
+    second_result = Post.find_with_index('crane',{:limit => 1, :offset => 1})
+    assert_equal 1, second_result.size
+    assert_equal all_results[1], second_result.first.id
+
+  end
+
+  # When a atom already in a record is duplicated, it removes
+  # all records with that same atom from the index.
+  def test_update_record_bug
+    assert_equal 2, Post.find_with_index('crane',{},{:ids_only => true}).size
+    p = Post.find(6)
+    assert p.update_attributes(:body => p.body + ' crane')
+    assert_equal 2, Post.find_with_index('crane',{},{:ids_only => true}).size
+    assert_equal 2, Post.find_with_index('ship',{},{:ids_only => true}).size
+  end
+
+end

data/vendor/plugins/acts_as_indexed/test/database.yml

@@ -0,0 +1,10 @@
+mysql:
+  :adapter: mysql
+  :host: localhost
+  :username: root
+  :password:
+  :database: rails_plugin_test
+
+sqlite3:
+  :adapter: sqlite3
+  :database: ':memory:'

data/vendor/plugins/acts_as_indexed/test/fixtures/post.rb

@@ -0,0 +1,5 @@
+class Post < ActiveRecord::Base
+  acts_as_indexed :fields => [:title, :body]
+  
+  validates_presence_of :title, :body
+end

data/vendor/plugins/acts_as_indexed/test/fixtures/posts.yml

@@ -0,0 +1,31 @@
+# Content generated using the random article feature on Wikipedia, http://en.wikipedia.org/wiki/Special:Random
+# Wikipedia content may be redistributed under the GNU Free Documentation License; http://en.wikipedia.org/wiki/Wikipedia:Text_of_the_GNU_Free_Documentation_License
+wikipedia_article_1:
+  id: 1
+  title: Body Count (video game)
+  body: Body Count is a 1994 First-person shooter for the Sega Mega Drive. It is one of the few games that make use of the Menacer light gun and the Mega Mouse. \n In the U.S. the game was released on the Sega Channel.
+  
+wikipedia_article_2:
+  id: 2
+  title: Julien Ellis
+  body: Julien Ellis is a ice hockey goalie, born in Sorel, Quebec on January 27, 1986. He is currently 6'0" and weighs approximately 177 pounds. He wears number 34 and catches left. \n Julien played his entire junior hockey career in the QMJHL with the Shawinigan Cataractes. He was there from 2002 through the 2006 season, and played a total of 173 regular season games for them. During his time there, he recorded eight shutouts, as well as a career high .921 save percentage and 2.41 goals against average. \n Julien was chosen in round six of the 2004 NHL Entry Draft by the Vancouver Canucks, making him 189th overall pick and the 5th pick for Vancouver. \n His 2006-07 season was spent with the Victoria Salmon Kings of the ECHL, where he played 37 games and made 1,212 saves. Julien was called up the the Manitoba Moose of the AHL several times, where he played eight games.
+  
+wikipedia_article_3:
+  id: 3
+  title: Tuen Mun River
+  body: The Tuen Mun River is a river in Tuen Mun, New Territories, Hong Kong. It has many tributaries, with major ones coming from Lam Tei, Kau Keng Shan, Hung Shui Hang and Nai Wai. It flows south, splitting Tuen Mun into a west side and an east side. It eventually feeds into the Tuen Mun Typhoon Shelter, which is part of Castle Peak Bay.
+  
+wikipedia_article_4:
+  id: 4
+  title: So Happily Unsatisfied
+  body: So Happily Unsatisfied is an album that was recorded by the band Nine Days. It was intended to be the follow-up to their successful major-label debut, The Madding Crowd from 2000. The release date of the album was repeatedly delayed by Sony until the band was ultimately dropped. In the interim, the album had leaked onto the internet. The band has also put the whole album on their official website for the public to download.
+  
+wikipedia_article_5:
+  id: 5
+  title: SS Cornhusker State (T-ACS-6)
+  body: SS Cornhusker State (T-ACS-6) is a crane ship in ready reserve for the United States Navy. She is stationed at Cheatham Annex in Williamsburg, Virginia and is in ready reserve under the Military Sealift Command. The ship was named for the state of Nebraska, which is also known as the Cornhusker State. \n The ship was built by the Bath Iron Works. Her keel was laid on 27 November 1967, launched on 2 November 1968, and delivered 20 June 1969 as CV Stag Hound (MA 207). \n Stag Hound was acquired by the US Navy from the Maritime Administration in 1986 and was converted throughout 1987. She re-entered service as Cornhusker State on 12 March 1988, and has been in ready reserve since 1993.
+  
+article_similar_to_5:
+  id: 6
+  title: An article I made up by myself!
+  body: crane crane big ship foo

data/vendor/plugins/acts_as_indexed/test/schema.rb

@@ -0,0 +1,6 @@
+ActiveRecord::Schema.define :version => 0 do
+  create_table :posts, :force => true do |t|
+    t.column :title, :string
+    t.column :body, :text
+  end
+end

data/vendor/plugins/acts_as_tree/README

@@ -0,0 +1,26 @@
+acts_as_tree
+============
+
+Specify this +acts_as+ extension if you want to model a tree structure by providing a parent association and a children
+association. This requires that you have a foreign key column, which by default is called +parent_id+.
+
+  class Category < ActiveRecord::Base
+    acts_as_tree :order => "name"
+  end
+
+  Example:
+  root
+   \_ child1
+        \_ subchild1
+        \_ subchild2
+
+  root      = Category.create("name" => "root")
+  child1    = root.children.create("name" => "child1")
+  subchild1 = child1.children.create("name" => "subchild1")
+
+  root.parent   # => nil
+  child1.parent # => root
+  root.children # => [child1]
+  root.children.first.children.first # => subchild1
+
+Copyright (c) 2007 David Heinemeier Hansson, released under the MIT license  

data/vendor/plugins/acts_as_tree/Rakefile

@@ -0,0 +1,22 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test acts_as_tree plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Generate documentation for acts_as_tree plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'acts_as_tree'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/vendor/plugins/acts_as_tree/init.rb

@@ -0,0 +1 @@
+ActiveRecord::Base.send :include, ActiveRecord::Acts::Tree

data/vendor/plugins/acts_as_tree/lib/active_record/acts/tree.rb

@@ -0,0 +1,141 @@
+module ActiveRecord
+  module Acts
+    module Tree
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      # Specify this +acts_as+ extension if you want to model a tree structure by providing a parent association and a children
+      # association. This requires that you have a foreign key column, which by default is called +parent_id+.
+      #
+      #   class Category < ActiveRecord::Base
+      #     acts_as_tree :order => "name"
+      #   end
+      #
+      #   Example:
+      #   root
+      #    \_ child1
+      #         \_ subchild1
+      #         \_ subchild2
+      #
+      #   root      = Category.create("name" => "root")
+      #   child1    = root.children.create("name" => "child1")
+      #   subchild1 = child1.children.create("name" => "subchild1")
+      #
+      #   root.parent   # => nil
+      #   child1.parent # => root
+      #   root.children # => [child1]
+      #   root.children.first.children.first # => subchild1
+      #
+      # In addition to the parent and children associations, the following instance methods are added to the class
+      # after calling <tt>acts_as_tree</tt>:
+      # * <tt>siblings</tt> - Returns all the children of the parent, excluding the current node (<tt>[subchild2]</tt> when called on <tt>subchild1</tt>)
+      # * <tt>self_and_siblings</tt> - Returns all the children of the parent, including the current node (<tt>[subchild1, subchild2]</tt> when called on <tt>subchild1</tt>)
+      # * <tt>ancestors</tt> - Returns all the ancestors of the current node (<tt>[child1, root]</tt> when called on <tt>subchild2</tt>)
+      # * <tt>root</tt> - Returns the root of the current node (<tt>root</tt> when called on <tt>subchild2</tt>)
+      # * <tt>descendants</tt> - Returns a flat list of the descendants of the current node (<tt>[child1, subchild1, subchild2]</tt> when called on <tt>root</tt>)
+      module ClassMethods
+        # Configuration options are:
+        #
+        # * <tt>foreign_key</tt> - specifies the column name to use for tracking of the tree (default: +parent_id+)
+        # * <tt>order</tt> - makes it possible to sort the children according to this SQL snippet.
+        # * <tt>counter_cache</tt> - keeps a count in a +children_count+ column if set to +true+ (default: +false+).
+        # * <tt>include</tt> - ability to add eager loading to tree finds by specifying associations to include. 'children' association eager loaded by default. Disable by supplying :include => nil or :include => []
+        def acts_as_tree(options = {})
+          configuration = { :foreign_key => "parent_id", :order => nil, :counter_cache => nil, :include => [:children] }
+          configuration.update(options) if options.is_a?(Hash) # to avoid something nasty happening check for Hash here.
+          configuration.update({:include => []}) if configuration[:include].nil? # if calling class really doesn't want to eager load its children.
+
+          belongs_to :parent, :class_name => name, :foreign_key => configuration[:foreign_key], :counter_cache => configuration[:counter_cache], :include => configuration[:include]
+          has_many :children, :class_name => name, :foreign_key => configuration[:foreign_key], :order => configuration[:order], :dependent => :delete_all, :include => configuration[:include]
+
+          class_eval <<-EOV
+            include ActiveRecord::Acts::Tree::InstanceMethods
+
+            def self.roots
+              find :all, :conditions => "#{configuration[:foreign_key]} IS NULL", :order => #{configuration[:order].nil? ? "nil" : %Q{"#{configuration[:order]}"}}, :include => %W{#{configuration[:include].join(' ')}}
+            end
+
+            def self.root
+              find :first, :conditions => "#{configuration[:foreign_key]} IS NULL", :order => #{configuration[:order].nil? ? "nil" : %Q{"#{configuration[:order]}"}}, :include => %W{#{configuration[:include].join(' ')}}
+            end
+
+            def self.childless
+              nodes = []
+
+              find(:all, :include => configuration[:include]).each do |node|
+                nodes << node if node.children.empty?
+              end
+
+              nodes
+            end
+          EOV
+        end
+      end
+
+      module InstanceMethods
+        # Returns list of ancestors, starting from parent until root.
+        #
+        #   subchild1.ancestors # => [child1, root]
+        def ancestors
+          node, nodes = self, []
+          nodes << node = node.parent until node.parent.nil? and return nodes
+        end
+
+        # Returns the root node of the tree.
+        def root
+          node = self
+          node = node.parent until node.parent.nil? and return node
+        end
+
+        # Returns all siblings of the current node.
+        #
+        #   subchild1.siblings # => [subchild2]
+        def siblings
+          self_and_siblings - [self]
+        end
+
+        # Returns all siblings and a reference to the current node.
+        #
+        #   subchild1.self_and_siblings # => [subchild1, subchild2]
+        def self_and_siblings
+          parent ? parent.children : self.class.roots
+        end
+
+        # Returns a flat list of the descendants of the current node.
+        #
+        #   root.descendants # => [child1, subchild1, subchild2]
+        def descendants(node=self)
+          nodes = []
+          nodes << node unless node == self
+
+          node.children.each do |child|
+            nodes += descendants(child)
+          end
+
+          nodes.compact
+        end
+
+        def chain
+          [self.ancestors, self, self.descendants].flatten
+        end
+
+        # Returns a flat list of all of the children under the current node
+        # which don't have any children belonging to them (childless)
+        #
+        #   node.childess # => [subchild1, subchild2]
+        def childless
+          nodes = []
+
+          unless self.children.empty?
+            nodes << self.children.collect { |child| child.childless }
+          else
+            nodes << self
+          end
+
+          nodes.flatten.compact
+        end
+      end
+    end
+  end
+end

data/vendor/plugins/acts_as_tree/test/acts_as_tree_test.rb

@@ -0,0 +1,219 @@
+require 'test/unit'
+
+require 'rubygems'
+require 'active_record'
+
+$:.unshift File.dirname(__FILE__) + '/../lib'
+require File.dirname(__FILE__) + '/../init'
+
+class Test::Unit::TestCase
+  def assert_queries(num = 1)
+    $query_count = 0
+    yield
+  ensure
+    assert_equal num, $query_count, "#{$query_count} instead of #{num} queries were executed."
+  end
+
+  def assert_no_queries(&block)
+    assert_queries(0, &block)
+  end
+end
+
+ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :dbfile => ":memory:")
+
+# AR keeps printing annoying schema statements
+$stdout = StringIO.new
+
+def setup_db
+  ActiveRecord::Base.logger
+  ActiveRecord::Schema.define(:version => 1) do
+    create_table :mixins do |t|
+      t.column :type, :string
+      t.column :parent_id, :integer
+    end
+  end
+end
+
+def teardown_db
+  ActiveRecord::Base.connection.tables.each do |table|
+    ActiveRecord::Base.connection.drop_table(table)
+  end
+end
+
+class Mixin < ActiveRecord::Base
+end
+
+class TreeMixin < Mixin
+  acts_as_tree :foreign_key => "parent_id", :order => "id"
+end
+
+class TreeMixinWithoutOrder < Mixin
+  acts_as_tree :foreign_key => "parent_id"
+end
+
+class RecursivelyCascadedTreeMixin < Mixin
+  acts_as_tree :foreign_key => "parent_id"
+  has_one :first_child, :class_name => 'RecursivelyCascadedTreeMixin', :foreign_key => :parent_id
+end
+
+class TreeTest < Test::Unit::TestCase
+
+  def setup
+    setup_db
+    @root1 = TreeMixin.create!
+    @root_child1 = TreeMixin.create! :parent_id => @root1.id
+    @child1_child = TreeMixin.create! :parent_id => @root_child1.id
+    @root_child2 = TreeMixin.create! :parent_id => @root1.id
+    @root2 = TreeMixin.create!
+    @root3 = TreeMixin.create!
+  end
+
+  def teardown
+    teardown_db
+  end
+
+  def test_children
+    assert_equal @root1.children, [@root_child1, @root_child2]
+    assert_equal @root_child1.children, [@child1_child]
+    assert_equal @child1_child.children, []
+    assert_equal @root_child2.children, []
+  end
+
+  def test_parent
+    assert_equal @root_child1.parent, @root1
+    assert_equal @root_child1.parent, @root_child2.parent
+    assert_nil @root1.parent
+  end
+
+  def test_delete
+    assert_equal 6, TreeMixin.count
+    @root1.destroy
+    assert_equal 2, TreeMixin.count
+    @root2.destroy
+    @root3.destroy
+    assert_equal 0, TreeMixin.count
+  end
+
+  def test_insert
+    @extra = @root1.children.create
+
+    assert @extra
+
+    assert_equal @extra.parent, @root1
+
+    assert_equal 3, @root1.children.size
+    assert @root1.children.include?(@extra)
+    assert @root1.children.include?(@root_child1)
+    assert @root1.children.include?(@root_child2)
+  end
+
+  def test_ancestors
+    assert_equal [], @root1.ancestors
+    assert_equal [@root1], @root_child1.ancestors
+    assert_equal [@root_child1, @root1], @child1_child.ancestors
+    assert_equal [@root1], @root_child2.ancestors
+    assert_equal [], @root2.ancestors
+    assert_equal [], @root3.ancestors
+  end
+
+  def test_root
+    assert_equal @root1, TreeMixin.root
+    assert_equal @root1, @root1.root
+    assert_equal @root1, @root_child1.root
+    assert_equal @root1, @child1_child.root
+    assert_equal @root1, @root_child2.root
+    assert_equal @root2, @root2.root
+    assert_equal @root3, @root3.root
+  end
+
+  def test_roots
+    assert_equal [@root1, @root2, @root3], TreeMixin.roots
+  end
+
+  def test_siblings
+    assert_equal [@root2, @root3], @root1.siblings
+    assert_equal [@root_child2], @root_child1.siblings
+    assert_equal [], @child1_child.siblings
+    assert_equal [@root_child1], @root_child2.siblings
+    assert_equal [@root1, @root3], @root2.siblings
+    assert_equal [@root1, @root2], @root3.siblings
+  end
+
+  def test_self_and_siblings
+    assert_equal [@root1, @root2, @root3], @root1.self_and_siblings
+    assert_equal [@root_child1, @root_child2], @root_child1.self_and_siblings
+    assert_equal [@child1_child], @child1_child.self_and_siblings
+    assert_equal [@root_child1, @root_child2], @root_child2.self_and_siblings
+    assert_equal [@root1, @root2, @root3], @root2.self_and_siblings
+    assert_equal [@root1, @root2, @root3], @root3.self_and_siblings
+  end
+end
+
+class TreeTestWithEagerLoading < Test::Unit::TestCase
+
+  def setup
+    teardown_db
+    setup_db
+    @root1 = TreeMixin.create!
+    @root_child1 = TreeMixin.create! :parent_id => @root1.id
+    @child1_child = TreeMixin.create! :parent_id => @root_child1.id
+    @root_child2 = TreeMixin.create! :parent_id => @root1.id
+    @root2 = TreeMixin.create!
+    @root3 = TreeMixin.create!
+
+    @rc1 = RecursivelyCascadedTreeMixin.create!
+    @rc2 = RecursivelyCascadedTreeMixin.create! :parent_id => @rc1.id
+    @rc3 = RecursivelyCascadedTreeMixin.create! :parent_id => @rc2.id
+    @rc4 = RecursivelyCascadedTreeMixin.create! :parent_id => @rc3.id
+  end
+
+  def teardown
+    teardown_db
+  end
+
+  def test_eager_association_loading
+    roots = TreeMixin.find(:all, :include => :children, :conditions => "mixins.parent_id IS NULL", :order => "mixins.id")
+    assert_equal [@root1, @root2, @root3], roots
+    assert_no_queries do
+      assert_equal 2, roots[0].children.size
+      assert_equal 0, roots[1].children.size
+      assert_equal 0, roots[2].children.size
+    end
+  end
+
+  def test_eager_association_loading_with_recursive_cascading_three_levels_has_many
+    root_node = RecursivelyCascadedTreeMixin.find(:first, :include => { :children => { :children => :children } }, :order => 'mixins.id')
+    assert_equal @rc4, assert_no_queries { root_node.children.first.children.first.children.first }
+  end
+
+  def test_eager_association_loading_with_recursive_cascading_three_levels_has_one
+    root_node = RecursivelyCascadedTreeMixin.find(:first, :include => { :first_child => { :first_child => :first_child } }, :order => 'mixins.id')
+    assert_equal @rc4, assert_no_queries { root_node.first_child.first_child.first_child }
+  end
+
+  def test_eager_association_loading_with_recursive_cascading_three_levels_belongs_to
+    leaf_node = RecursivelyCascadedTreeMixin.find(:first, :include => { :parent => { :parent => :parent } }, :order => 'mixins.id DESC')
+    assert_equal @rc1, assert_no_queries { leaf_node.parent.parent.parent }
+  end
+end
+
+class TreeTestWithoutOrder < Test::Unit::TestCase
+
+  def setup
+    setup_db
+    @root1 = TreeMixinWithoutOrder.create!
+    @root2 = TreeMixinWithoutOrder.create!
+  end
+
+  def teardown
+    teardown_db
+  end
+
+  def test_root
+    assert [@root1, @root2].include?(TreeMixinWithoutOrder.root)
+  end
+
+  def test_roots
+    assert_equal [], [@root1, @root2] - TreeMixinWithoutOrder.roots
+  end
+end