From e0a7e0fec760ba12c8067a37e10c96f1f05876e2 Mon Sep 17 00:00:00 2001 From: erdgeist Date: Wed, 24 Jun 2026 04:13:16 +0200 Subject: Stage 1 complete: Rails 2.3.5 to Rails 3.2.22.5 upgrade - Converted plugins to gems (Gemfile) - Updated config structure (application.rb, boot.rb, environment.rb) - Converted routes to Rails 3 DSL - Converted named_scope to scope throughout models - Converted find(:all, :conditions) to where() chains - Fixed has_many :order to use ordering scope - Updated session store and secret token configuration - Fixed exception_notification middleware configuration - Patched Ruby 2.4 / Rails 3.2 incompatibilities: - Integer/Float duration arithmetic (ActiveSupport) - Arel visit_Integer for PostgreSQL adapter - create_database String/Integer coercion - ActionController consider_all_requests_local - Migrated taggings schema for acts-as-taggable-on - Replaced dynamic_form gem with custom form_error_messages helper - Fixed Rails 3 block helper syntax (form_for, form_tag, fields_for) - Fixed admin layout yield - Updated test suite for Rails 3 APIs --- .../plugins/awesome_nested_set/test/application.rb | 1 - .../test/awesome_nested_set/helper_test.rb | 41 -- .../test/awesome_nested_set_test.rb | 748 --------------------- .../test/fixtures/categories.yml | 34 - .../awesome_nested_set/test/fixtures/category.rb | 15 - .../test/fixtures/departments.yml | 3 - .../awesome_nested_set/test/fixtures/notes.yml | 38 -- .../plugins/awesome_nested_set/test/test_helper.rb | 29 - 8 files changed, 909 deletions(-) delete mode 100644 vendor/plugins/awesome_nested_set/test/application.rb delete mode 100644 vendor/plugins/awesome_nested_set/test/awesome_nested_set/helper_test.rb delete mode 100644 vendor/plugins/awesome_nested_set/test/awesome_nested_set_test.rb delete mode 100644 vendor/plugins/awesome_nested_set/test/fixtures/categories.yml delete mode 100644 vendor/plugins/awesome_nested_set/test/fixtures/category.rb delete mode 100644 vendor/plugins/awesome_nested_set/test/fixtures/departments.yml delete mode 100644 vendor/plugins/awesome_nested_set/test/fixtures/notes.yml delete mode 100644 vendor/plugins/awesome_nested_set/test/test_helper.rb (limited to 'vendor/plugins/awesome_nested_set/test') diff --git a/vendor/plugins/awesome_nested_set/test/application.rb b/vendor/plugins/awesome_nested_set/test/application.rb deleted file mode 100644 index 0e6eacfd..00000000 --- a/vendor/plugins/awesome_nested_set/test/application.rb +++ /dev/null @@ -1 +0,0 @@ -# This file is here to satisfy test_help from Rails < 2.3 \ No newline at end of file diff --git a/vendor/plugins/awesome_nested_set/test/awesome_nested_set/helper_test.rb b/vendor/plugins/awesome_nested_set/test/awesome_nested_set/helper_test.rb deleted file mode 100644 index 888323cc..00000000 --- a/vendor/plugins/awesome_nested_set/test/awesome_nested_set/helper_test.rb +++ /dev/null @@ -1,41 +0,0 @@ -require 'test_helper' - -module CollectiveIdea - module Acts #:nodoc: - module NestedSet #:nodoc: - class AwesomeNestedSetTest < TestCaseClass - include Helper - fixtures :categories - - def test_nested_set_options - expected = [ - [" Top Level", 1], - ["- Child 1", 2], - ['- Child 2', 3], - ['-- Child 2.1', 4], - ['- Child 3', 5], - [" Top Level 2", 6] - ] - actual = nested_set_options(Category) do |c| - "#{'-' * c.level} #{c.name}" - end - assert_equal expected, actual - end - - def test_nested_set_options_with_mover - expected = [ - [" Top Level", 1], - ["- Child 1", 2], - ['- Child 3', 5], - [" Top Level 2", 6] - ] - actual = nested_set_options(Category, categories(:child_2)) do |c| - "#{'-' * c.level} #{c.name}" - end - assert_equal expected, actual - end - - end - end - end -end diff --git a/vendor/plugins/awesome_nested_set/test/awesome_nested_set_test.rb b/vendor/plugins/awesome_nested_set/test/awesome_nested_set_test.rb deleted file mode 100644 index 7b587de7..00000000 --- a/vendor/plugins/awesome_nested_set/test/awesome_nested_set_test.rb +++ /dev/null @@ -1,748 +0,0 @@ -require 'test_helper' - -class Note < ActiveRecord::Base - acts_as_nested_set :scope => [:notable_id, :notable_type] -end -class Default < ActiveRecord::Base - acts_as_nested_set - set_table_name 'categories' -end -class ScopedCategory < ActiveRecord::Base - acts_as_nested_set :scope => :organization - set_table_name 'categories' -end -class RenamedColumns < ActiveRecord::Base - acts_as_nested_set :parent_column => 'mother_id', :left_column => 'red', :right_column => 'black' -end - -class AwesomeNestedSetTest < TestCaseClass - - def test_left_column_default - assert_equal 'lft', Default.acts_as_nested_set_options[:left_column] - end - - def test_right_column_default - assert_equal 'rgt', Default.acts_as_nested_set_options[:right_column] - end - - def test_parent_column_default - assert_equal 'parent_id', Default.acts_as_nested_set_options[:parent_column] - end - - def test_scope_default - assert_nil Default.acts_as_nested_set_options[:scope] - end - - def test_left_column_name - assert_equal 'lft', Default.left_column_name - assert_equal 'lft', Default.new.left_column_name - assert_equal 'red', RenamedColumns.left_column_name - assert_equal 'red', RenamedColumns.new.left_column_name - end - - def test_right_column_name - assert_equal 'rgt', Default.right_column_name - assert_equal 'rgt', Default.new.right_column_name - assert_equal 'black', RenamedColumns.right_column_name - assert_equal 'black', RenamedColumns.new.right_column_name - end - - def test_parent_column_name - assert_equal 'parent_id', Default.parent_column_name - assert_equal 'parent_id', Default.new.parent_column_name - assert_equal 'mother_id', RenamedColumns.parent_column_name - assert_equal 'mother_id', RenamedColumns.new.parent_column_name - end - - def test_creation_with_altered_column_names - assert_nothing_raised do - RenamedColumns.create!() - end - end - - def test_quoted_left_column_name - quoted = Default.connection.quote_column_name('lft') - assert_equal quoted, Default.quoted_left_column_name - assert_equal quoted, Default.new.quoted_left_column_name - end - - def test_quoted_right_column_name - quoted = Default.connection.quote_column_name('rgt') - assert_equal quoted, Default.quoted_right_column_name - assert_equal quoted, Default.new.quoted_right_column_name - end - - def test_left_column_protected_from_assignment - assert_raises(ActiveRecord::ActiveRecordError) { Category.new.lft = 1 } - end - - def test_right_column_protected_from_assignment - assert_raises(ActiveRecord::ActiveRecordError) { Category.new.rgt = 1 } - end - - def test_colums_protected_on_initialize - c = Category.new(:lft => 1, :rgt => 2) - assert_nil c.lft - assert_nil c.rgt - end - - def test_scoped_appends_id - assert_equal :organization_id, ScopedCategory.acts_as_nested_set_options[:scope] - end - - def test_roots_class_method - assert_equal Category.find_all_by_parent_id(nil), Category.roots - end - - def test_root_class_method - assert_equal categories(:top_level), Category.root - end - - def test_root - assert_equal categories(:top_level), categories(:child_3).root - end - - def test_root? - assert categories(:top_level).root? - assert categories(:top_level_2).root? - end - - def test_leaves_class_method - assert_equal Category.find(:all, :conditions => "#{Category.right_column_name} - #{Category.left_column_name} = 1"), Category.leaves - assert_equal Category.leaves.count, 4 - assert (Category.leaves.include? categories(:child_1)) - assert (Category.leaves.include? categories(:child_2_1)) - assert (Category.leaves.include? categories(:child_3)) - assert (Category.leaves.include? categories(:top_level_2)) - end - - def test_leaf - assert categories(:child_1).leaf? - assert categories(:child_2_1).leaf? - assert categories(:child_3).leaf? - assert categories(:top_level_2).leaf? - - assert !categories(:top_level).leaf? - assert !categories(:child_2).leaf? - assert !Category.new.leaf? - end - - - def test_parent - assert_equal categories(:child_2), categories(:child_2_1).parent - end - - def test_self_and_ancestors - child = categories(:child_2_1) - self_and_ancestors = [categories(:top_level), categories(:child_2), child] - assert_equal self_and_ancestors, child.self_and_ancestors - end - - def test_ancestors - child = categories(:child_2_1) - ancestors = [categories(:top_level), categories(:child_2)] - assert_equal ancestors, child.ancestors - end - - def test_self_and_siblings - child = categories(:child_2) - self_and_siblings = [categories(:child_1), child, categories(:child_3)] - assert_equal self_and_siblings, child.self_and_siblings - assert_nothing_raised do - tops = [categories(:top_level), categories(:top_level_2)] - assert_equal tops, categories(:top_level).self_and_siblings - end - end - - def test_siblings - child = categories(:child_2) - siblings = [categories(:child_1), categories(:child_3)] - assert_equal siblings, child.siblings - end - - def test_leaves - leaves = [categories(:child_1), categories(:child_2_1), categories(:child_3), categories(:top_level_2)] - assert categories(:top_level).leaves, leaves - end - - def test_level - assert_equal 0, categories(:top_level).level - assert_equal 1, categories(:child_1).level - assert_equal 2, categories(:child_2_1).level - end - - def test_has_children? - assert categories(:child_2_1).children.empty? - assert !categories(:child_2).children.empty? - assert !categories(:top_level).children.empty? - end - - def test_self_and_descendents - parent = categories(:top_level) - self_and_descendants = [parent, categories(:child_1), categories(:child_2), - categories(:child_2_1), categories(:child_3)] - assert_equal self_and_descendants, parent.self_and_descendants - assert_equal self_and_descendants, parent.self_and_descendants.count - end - - def test_descendents - lawyers = Category.create!(:name => "lawyers") - us = Category.create!(:name => "United States") - us.move_to_child_of(lawyers) - patent = Category.create!(:name => "Patent Law") - patent.move_to_child_of(us) - lawyers.reload - - assert_equal 1, lawyers.children.size - assert_equal 1, us.children.size - assert_equal 2, lawyers.descendants.size - end - - def test_self_and_descendents - parent = categories(:top_level) - descendants = [categories(:child_1), categories(:child_2), - categories(:child_2_1), categories(:child_3)] - assert_equal descendants, parent.descendants - end - - def test_children - category = categories(:top_level) - category.children.each {|c| assert_equal category.id, c.parent_id } - end - - def test_order_of_children - categories(:child_2).move_left - assert_equal categories(:child_2), categories(:top_level).children[0] - assert_equal categories(:child_1), categories(:top_level).children[1] - assert_equal categories(:child_3), categories(:top_level).children[2] - end - - def test_is_or_is_ancestor_of? - assert categories(:top_level).is_or_is_ancestor_of?(categories(:child_1)) - assert categories(:top_level).is_or_is_ancestor_of?(categories(:child_2_1)) - assert categories(:child_2).is_or_is_ancestor_of?(categories(:child_2_1)) - assert !categories(:child_2_1).is_or_is_ancestor_of?(categories(:child_2)) - assert !categories(:child_1).is_or_is_ancestor_of?(categories(:child_2)) - assert categories(:child_1).is_or_is_ancestor_of?(categories(:child_1)) - end - - def test_is_ancestor_of? - assert categories(:top_level).is_ancestor_of?(categories(:child_1)) - assert categories(:top_level).is_ancestor_of?(categories(:child_2_1)) - assert categories(:child_2).is_ancestor_of?(categories(:child_2_1)) - assert !categories(:child_2_1).is_ancestor_of?(categories(:child_2)) - assert !categories(:child_1).is_ancestor_of?(categories(:child_2)) - assert !categories(:child_1).is_ancestor_of?(categories(:child_1)) - end - - def test_is_or_is_ancestor_of_with_scope - root = ScopedCategory.root - child = root.children.first - assert root.is_or_is_ancestor_of?(child) - child.update_attribute :organization_id, 'different' - assert !root.is_or_is_ancestor_of?(child) - end - - def test_is_or_is_descendant_of? - assert categories(:child_1).is_or_is_descendant_of?(categories(:top_level)) - assert categories(:child_2_1).is_or_is_descendant_of?(categories(:top_level)) - assert categories(:child_2_1).is_or_is_descendant_of?(categories(:child_2)) - assert !categories(:child_2).is_or_is_descendant_of?(categories(:child_2_1)) - assert !categories(:child_2).is_or_is_descendant_of?(categories(:child_1)) - assert categories(:child_1).is_or_is_descendant_of?(categories(:child_1)) - end - - def test_is_descendant_of? - assert categories(:child_1).is_descendant_of?(categories(:top_level)) - assert categories(:child_2_1).is_descendant_of?(categories(:top_level)) - assert categories(:child_2_1).is_descendant_of?(categories(:child_2)) - assert !categories(:child_2).is_descendant_of?(categories(:child_2_1)) - assert !categories(:child_2).is_descendant_of?(categories(:child_1)) - assert !categories(:child_1).is_descendant_of?(categories(:child_1)) - end - - def test_is_or_is_descendant_of_with_scope - root = ScopedCategory.root - child = root.children.first - assert child.is_or_is_descendant_of?(root) - child.update_attribute :organization_id, 'different' - assert !child.is_or_is_descendant_of?(root) - end - - def test_same_scope? - root = ScopedCategory.root - child = root.children.first - assert child.same_scope?(root) - child.update_attribute :organization_id, 'different' - assert !child.same_scope?(root) - end - - def test_left_sibling - assert_equal categories(:child_1), categories(:child_2).left_sibling - assert_equal categories(:child_2), categories(:child_3).left_sibling - end - - def test_left_sibling_of_root - assert_nil categories(:top_level).left_sibling - end - - def test_left_sibling_without_siblings - assert_nil categories(:child_2_1).left_sibling - end - - def test_left_sibling_of_leftmost_node - assert_nil categories(:child_1).left_sibling - end - - def test_right_sibling - assert_equal categories(:child_3), categories(:child_2).right_sibling - assert_equal categories(:child_2), categories(:child_1).right_sibling - end - - def test_right_sibling_of_root - assert_equal categories(:top_level_2), categories(:top_level).right_sibling - assert_nil categories(:top_level_2).right_sibling - end - - def test_right_sibling_without_siblings - assert_nil categories(:child_2_1).right_sibling - end - - def test_right_sibling_of_rightmost_node - assert_nil categories(:child_3).right_sibling - end - - def test_move_left - categories(:child_2).move_left - assert_nil categories(:child_2).left_sibling - assert_equal categories(:child_1), categories(:child_2).right_sibling - assert Category.valid? - end - - def test_move_right - categories(:child_2).move_right - assert_nil categories(:child_2).right_sibling - assert_equal categories(:child_3), categories(:child_2).left_sibling - assert Category.valid? - end - - def test_move_to_left_of - categories(:child_3).move_to_left_of(categories(:child_1)) - assert_nil categories(:child_3).left_sibling - assert_equal categories(:child_1), categories(:child_3).right_sibling - assert Category.valid? - end - - def test_move_to_right_of - categories(:child_1).move_to_right_of(categories(:child_3)) - assert_nil categories(:child_1).right_sibling - assert_equal categories(:child_3), categories(:child_1).left_sibling - assert Category.valid? - end - - def test_move_to_root - categories(:child_2).move_to_root - assert_nil categories(:child_2).parent - assert_equal 0, categories(:child_2).level - assert_equal 1, categories(:child_2_1).level - assert_equal 1, categories(:child_2).left - assert_equal 4, categories(:child_2).right - assert Category.valid? - end - - def test_move_to_child_of - categories(:child_1).move_to_child_of(categories(:child_3)) - assert_equal categories(:child_3).id, categories(:child_1).parent_id - assert Category.valid? - end - - def test_move_to_child_of_appends_to_end - child = Category.create! :name => 'New Child' - child.move_to_child_of categories(:top_level) - assert_equal child, categories(:top_level).children.last - end - - def test_subtree_move_to_child_of - assert_equal 4, categories(:child_2).left - assert_equal 7, categories(:child_2).right - - assert_equal 2, categories(:child_1).left - assert_equal 3, categories(:child_1).right - - categories(:child_2).move_to_child_of(categories(:child_1)) - assert Category.valid? - assert_equal categories(:child_1).id, categories(:child_2).parent_id - - assert_equal 3, categories(:child_2).left - assert_equal 6, categories(:child_2).right - assert_equal 2, categories(:child_1).left - assert_equal 7, categories(:child_1).right - end - - def test_slightly_difficult_move_to_child_of - assert_equal 11, categories(:top_level_2).left - assert_equal 12, categories(:top_level_2).right - - # create a new top-level node and move single-node top-level tree inside it. - new_top = Category.create(:name => 'New Top') - assert_equal 13, new_top.left - assert_equal 14, new_top.right - - categories(:top_level_2).move_to_child_of(new_top) - - assert Category.valid? - assert_equal new_top.id, categories(:top_level_2).parent_id - - assert_equal 12, categories(:top_level_2).left - assert_equal 13, categories(:top_level_2).right - assert_equal 11, new_top.left - assert_equal 14, new_top.right - end - - def test_difficult_move_to_child_of - assert_equal 1, categories(:top_level).left - assert_equal 10, categories(:top_level).right - assert_equal 5, categories(:child_2_1).left - assert_equal 6, categories(:child_2_1).right - - # create a new top-level node and move an entire top-level tree inside it. - new_top = Category.create(:name => 'New Top') - categories(:top_level).move_to_child_of(new_top) - categories(:child_2_1).reload - assert Category.valid? - assert_equal new_top.id, categories(:top_level).parent_id - - assert_equal 4, categories(:top_level).left - assert_equal 13, categories(:top_level).right - assert_equal 8, categories(:child_2_1).left - assert_equal 9, categories(:child_2_1).right - end - - #rebuild swaps the position of the 2 children when added using move_to_child twice onto same parent - def test_move_to_child_more_than_once_per_parent_rebuild - root1 = Category.create(:name => 'Root1') - root2 = Category.create(:name => 'Root2') - root3 = Category.create(:name => 'Root3') - - root2.move_to_child_of root1 - root3.move_to_child_of root1 - - output = Category.roots.last.to_text - Category.update_all('lft = null, rgt = null') - Category.rebuild! - - assert_equal Category.roots.last.to_text, output - end - - # doing move_to_child twice onto same parent from the furthest right first - def test_move_to_child_more_than_once_per_parent_outside_in - node1 = Category.create(:name => 'Node-1') - node2 = Category.create(:name => 'Node-2') - node3 = Category.create(:name => 'Node-3') - - node2.move_to_child_of node1 - node3.move_to_child_of node1 - - output = Category.roots.last.to_text - Category.update_all('lft = null, rgt = null') - Category.rebuild! - - assert_equal Category.roots.last.to_text, output - end - - - def test_valid_with_null_lefts - assert Category.valid? - Category.update_all('lft = null') - assert !Category.valid? - end - - def test_valid_with_null_rights - assert Category.valid? - Category.update_all('rgt = null') - assert !Category.valid? - end - - def test_valid_with_missing_intermediate_node - # Even though child_2_1 will still exist, it is a sign of a sloppy delete, not an invalid tree. - assert Category.valid? - Category.delete(categories(:child_2).id) - assert Category.valid? - end - - def test_valid_with_overlapping_and_rights - assert Category.valid? - categories(:top_level_2)['lft'] = 0 - categories(:top_level_2).save - assert !Category.valid? - end - - def test_rebuild - assert Category.valid? - before_text = Category.root.to_text - Category.update_all('lft = null, rgt = null') - Category.rebuild! - assert Category.valid? - assert_equal before_text, Category.root.to_text - end - - def test_move_possible_for_sibling - assert categories(:child_2).move_possible?(categories(:child_1)) - end - - def test_move_not_possible_to_self - assert !categories(:top_level).move_possible?(categories(:top_level)) - end - - def test_move_not_possible_to_parent - categories(:top_level).descendants.each do |descendant| - assert !categories(:top_level).move_possible?(descendant) - assert descendant.move_possible?(categories(:top_level)) - end - end - - def test_is_or_is_ancestor_of? - [:child_1, :child_2, :child_2_1, :child_3].each do |c| - assert categories(:top_level).is_or_is_ancestor_of?(categories(c)) - end - assert !categories(:top_level).is_or_is_ancestor_of?(categories(:top_level_2)) - end - - def test_left_and_rights_valid_with_blank_left - assert Category.left_and_rights_valid? - categories(:child_2)[:lft] = nil - categories(:child_2).save(false) - assert !Category.left_and_rights_valid? - end - - def test_left_and_rights_valid_with_blank_right - assert Category.left_and_rights_valid? - categories(:child_2)[:rgt] = nil - categories(:child_2).save(false) - assert !Category.left_and_rights_valid? - end - - def test_left_and_rights_valid_with_equal - assert Category.left_and_rights_valid? - categories(:top_level_2)[:lft] = categories(:top_level_2)[:rgt] - categories(:top_level_2).save(false) - assert !Category.left_and_rights_valid? - end - - def test_left_and_rights_valid_with_left_equal_to_parent - assert Category.left_and_rights_valid? - categories(:child_2)[:lft] = categories(:top_level)[:lft] - categories(:child_2).save(false) - assert !Category.left_and_rights_valid? - end - - def test_left_and_rights_valid_with_right_equal_to_parent - assert Category.left_and_rights_valid? - categories(:child_2)[:rgt] = categories(:top_level)[:rgt] - categories(:child_2).save(false) - assert !Category.left_and_rights_valid? - end - - def test_moving_dirty_objects_doesnt_invalidate_tree - r1 = Category.create - r2 = Category.create - r3 = Category.create - r4 = Category.create - nodes = [r1, r2, r3, r4] - - r2.move_to_child_of(r1) - assert Category.valid? - - r3.move_to_child_of(r1) - assert Category.valid? - - r4.move_to_child_of(r2) - assert Category.valid? - end - - def test_multi_scoped_no_duplicates_for_columns? - assert_nothing_raised do - Note.no_duplicates_for_columns? - end - end - - def test_multi_scoped_all_roots_valid? - assert_nothing_raised do - Note.all_roots_valid? - end - end - - def test_multi_scoped - note1 = Note.create!(:body => "A", :notable_id => 2, :notable_type => 'Category') - note2 = Note.create!(:body => "B", :notable_id => 2, :notable_type => 'Category') - note3 = Note.create!(:body => "C", :notable_id => 2, :notable_type => 'Default') - - assert_equal [note1, note2], note1.self_and_siblings - assert_equal [note3], note3.self_and_siblings - end - - def test_multi_scoped_rebuild - root = Note.create!(:body => "A", :notable_id => 3, :notable_type => 'Category') - child1 = Note.create!(:body => "B", :notable_id => 3, :notable_type => 'Category') - child2 = Note.create!(:body => "C", :notable_id => 3, :notable_type => 'Category') - - child1.move_to_child_of root - child2.move_to_child_of root - - Note.update_all('lft = null, rgt = null') - Note.rebuild! - - assert_equal Note.roots.find_by_body('A'), root - assert_equal [child1, child2], Note.roots.find_by_body('A').children - end - - def test_same_scope_with_multi_scopes - assert_nothing_raised do - notes(:scope1).same_scope?(notes(:child_1)) - end - assert notes(:scope1).same_scope?(notes(:child_1)) - assert notes(:child_1).same_scope?(notes(:scope1)) - assert !notes(:scope1).same_scope?(notes(:scope2)) - end - - def test_quoting_of_multi_scope_column_names - assert_equal ["\"notable_id\"", "\"notable_type\""], Note.quoted_scope_column_names - end - - def test_equal_in_same_scope - assert_equal notes(:scope1), notes(:scope1) - assert_not_equal notes(:scope1), notes(:child_1) - end - - def test_equal_in_different_scopes - assert_not_equal notes(:scope1), notes(:scope2) - end - - def test_delete_does_not_invalidate - Category.acts_as_nested_set_options[:dependent] = :delete - categories(:child_2).destroy - assert Category.valid? - end - - def test_destroy_does_not_invalidate - Category.acts_as_nested_set_options[:dependent] = :destroy - categories(:child_2).destroy - assert Category.valid? - end - - def test_destroy_multiple_times_does_not_invalidate - Category.acts_as_nested_set_options[:dependent] = :destroy - categories(:child_2).destroy - categories(:child_2).destroy - assert Category.valid? - end - - def test_assigning_parent_id_on_create - category = Category.create!(:name => "Child", :parent_id => categories(:child_2).id) - assert_equal categories(:child_2), category.parent - assert_equal categories(:child_2).id, category.parent_id - assert_not_nil category.left - assert_not_nil category.right - assert Category.valid? - end - - def test_assigning_parent_on_create - category = Category.create!(:name => "Child", :parent => categories(:child_2)) - assert_equal categories(:child_2), category.parent - assert_equal categories(:child_2).id, category.parent_id - assert_not_nil category.left - assert_not_nil category.right - assert Category.valid? - end - - def test_assigning_parent_id_to_nil_on_create - category = Category.create!(:name => "New Root", :parent_id => nil) - assert_nil category.parent - assert_nil category.parent_id - assert_not_nil category.left - assert_not_nil category.right - assert Category.valid? - end - - def test_assigning_parent_id_on_update - category = categories(:child_2_1) - category.parent_id = categories(:child_3).id - category.save - assert_equal categories(:child_3), category.parent - assert_equal categories(:child_3).id, category.parent_id - assert Category.valid? - end - - def test_assigning_parent_on_update - category = categories(:child_2_1) - category.parent = categories(:child_3) - category.save - assert_equal categories(:child_3), category.parent - assert_equal categories(:child_3).id, category.parent_id - assert Category.valid? - end - - def test_assigning_parent_id_to_nil_on_update - category = categories(:child_2_1) - category.parent_id = nil - category.save - assert_nil category.parent - assert_nil category.parent_id - assert Category.valid? - end - - def test_creating_child_from_parent - category = categories(:child_2).children.create!(:name => "Child") - assert_equal categories(:child_2), category.parent - assert_equal categories(:child_2).id, category.parent_id - assert_not_nil category.left - assert_not_nil category.right - assert Category.valid? - end - - def check_structure(entries, structure) - structure = structure.dup - Category.each_with_level(entries) do |category, level| - expected_level, expected_name = structure.shift - assert_equal expected_name, category.name, "wrong category" - assert_equal expected_level, level, "wrong level for #{category.name}" - end - end - - def test_each_with_level - levels = [ - [0, "Top Level"], - [1, "Child 1"], - [1, "Child 2"], - [2, "Child 2.1"], - [1, "Child 3" ]] - - check_structure(Category.root.self_and_descendants, levels) - - # test some deeper structures - category = Category.find_by_name("Child 1") - c1 = Category.new(:name => "Child 1.1") - c2 = Category.new(:name => "Child 1.1.1") - c3 = Category.new(:name => "Child 1.1.1.1") - c4 = Category.new(:name => "Child 1.2") - [c1, c2, c3, c4].each(&:save!) - - c1.move_to_child_of(category) - c2.move_to_child_of(c1) - c3.move_to_child_of(c2) - c4.move_to_child_of(category) - - levels = [ - [0, "Top Level"], - [1, "Child 1"], - [2, "Child 1.1"], - [3, "Child 1.1.1"], - [4, "Child 1.1.1.1"], - [2, "Child 1.2"], - [1, "Child 2"], - [2, "Child 2.1"], - [1, "Child 3" ]] - - check_structure(Category.root.self_and_descendants, levels) - end -end diff --git a/vendor/plugins/awesome_nested_set/test/fixtures/categories.yml b/vendor/plugins/awesome_nested_set/test/fixtures/categories.yml deleted file mode 100644 index bc8e078e..00000000 --- a/vendor/plugins/awesome_nested_set/test/fixtures/categories.yml +++ /dev/null @@ -1,34 +0,0 @@ -top_level: - id: 1 - name: Top Level - lft: 1 - rgt: 10 -child_1: - id: 2 - name: Child 1 - parent_id: 1 - lft: 2 - rgt: 3 -child_2: - id: 3 - name: Child 2 - parent_id: 1 - lft: 4 - rgt: 7 -child_2_1: - id: 4 - name: Child 2.1 - parent_id: 3 - lft: 5 - rgt: 6 -child_3: - id: 5 - name: Child 3 - parent_id: 1 - lft: 8 - rgt: 9 -top_level_2: - id: 6 - name: Top Level 2 - lft: 11 - rgt: 12 diff --git a/vendor/plugins/awesome_nested_set/test/fixtures/category.rb b/vendor/plugins/awesome_nested_set/test/fixtures/category.rb deleted file mode 100644 index 506b0dac..00000000 --- a/vendor/plugins/awesome_nested_set/test/fixtures/category.rb +++ /dev/null @@ -1,15 +0,0 @@ -class Category < ActiveRecord::Base - acts_as_nested_set - - def to_s - name - end - - def recurse &block - block.call self, lambda{ - self.children.each do |child| - child.recurse &block - end - } - end -end \ No newline at end of file diff --git a/vendor/plugins/awesome_nested_set/test/fixtures/departments.yml b/vendor/plugins/awesome_nested_set/test/fixtures/departments.yml deleted file mode 100644 index e50a944f..00000000 --- a/vendor/plugins/awesome_nested_set/test/fixtures/departments.yml +++ /dev/null @@ -1,3 +0,0 @@ -top: - id: 1 - name: Top \ No newline at end of file diff --git a/vendor/plugins/awesome_nested_set/test/fixtures/notes.yml b/vendor/plugins/awesome_nested_set/test/fixtures/notes.yml deleted file mode 100644 index 004a5335..00000000 --- a/vendor/plugins/awesome_nested_set/test/fixtures/notes.yml +++ /dev/null @@ -1,38 +0,0 @@ -scope1: - id: 1 - body: Top Level - lft: 1 - rgt: 10 - notable_id: 1 - notable_type: Category -child_1: - id: 2 - body: Child 1 - parent_id: 1 - lft: 2 - rgt: 3 - notable_id: 1 - notable_type: Category -child_2: - id: 3 - body: Child 2 - parent_id: 1 - lft: 4 - rgt: 7 - notable_id: 1 - notable_type: Category -child_3: - id: 4 - body: Child 3 - parent_id: 1 - lft: 8 - rgt: 9 - notable_id: 1 - notable_type: Category -scope2: - id: 5 - body: Top Level 2 - lft: 1 - rgt: 2 - notable_id: 1 - notable_type: Departments diff --git a/vendor/plugins/awesome_nested_set/test/test_helper.rb b/vendor/plugins/awesome_nested_set/test/test_helper.rb deleted file mode 100644 index 05d88556..00000000 --- a/vendor/plugins/awesome_nested_set/test/test_helper.rb +++ /dev/null @@ -1,29 +0,0 @@ -$:.unshift(File.dirname(__FILE__) + '/../lib') -plugin_test_dir = File.dirname(__FILE__) -RAILS_ROOT = plugin_test_dir - -require 'rubygems' -require 'test/unit' -require 'multi_rails_init' -require 'test_help' - -require plugin_test_dir + '/../init.rb' - -TestCaseClass = ActiveSupport::TestCase rescue Test::Unit::TestCase - -ActiveRecord::Base.logger = Logger.new(plugin_test_dir + "/debug.log") - -ActiveRecord::Base.configurations = YAML::load(IO.read(plugin_test_dir + "/db/database.yml")) -ActiveRecord::Base.establish_connection(ENV["DB"] || "sqlite3mem") -ActiveRecord::Migration.verbose = false -load(File.join(plugin_test_dir, "db", "schema.rb")) - -Dir["#{plugin_test_dir}/fixtures/*.rb"].each {|file| require file } - -class TestCaseClass #:nodoc: - self.fixture_path = File.dirname(__FILE__) + "/fixtures/" - self.use_transactional_fixtures = true - self.use_instantiated_fixtures = false - - fixtures :categories, :notes, :departments -end -- cgit v1.3