acts_as_ordered_tree 1.3.1 → 2.0.0.beta3

data/spec/spec_helper.rb

@@ -1,62 +1,54 @@
 ENV['DB'] ||= 'pg'
-test_dir = File.dirname(__FILE__)
 
 require 'rubygems'
 require 'bundler/setup'
 
 require 'rspec'
-require 'rspec-expectations'
-
-begin
-  require 'simplecov'
-  SimpleCov.start
-rescue LoadError
-  #ignore
+require 'rspec/expectations'
+
+if ENV['COVERAGE'].to_i.nonzero?
+  begin
+    require 'simplecov'
+    SimpleCov.command_name "rspec/#{File.basename(ENV['BUNDLE_GEMFILE'])}/#{ENV['DB']}"
+    SimpleCov.start 'test_frameworks' do
+      add_filter 'vendor/'
+    end
+  rescue LoadError
+    #ignore
+  end
 end
 
-require 'active_record'
-require 'factory_girl'
-
-require 'acts_as_ordered_tree'
-require 'logger'
-require 'yaml'
-require 'erb'
-
-config_file = ENV['DBCONF'] || 'config.yml'
+require 'support/db/boot'
 
-ActiveRecord::Base.configurations = YAML::load(ERB.new(IO.read(File.join(test_dir, 'db', config_file))).result)
-ActiveRecord::Base.establish_connection(ENV['DB'])
-ActiveRecord::Base.logger = Logger.new(ENV['DEBUG'] ? $stderr : '/dev/null')
-ActiveRecord::Migration.verbose = false
-I18n.enforce_available_locales = false if I18n.respond_to?(:enforce_available_locales=)
-load(File.join(test_dir, 'db', 'schema.rb'))
-
-require 'shoulda-matchers'
-require 'support/models'
+require 'factory_girl'
 require 'support/factories'
 require 'support/matchers'
+require 'support/tree_factory'
+require 'database_cleaner'
 
 RSpec.configure do |config|
   config.include FactoryGirl::Syntax::Methods
+  config.extend TreeFactory
 
   config.treat_symbols_as_metadata_keys_with_true_values = true
 
   config.around :each, :transactional do |example|
-    ActiveRecord::Base.transaction do
-      example.run
+    DatabaseCleaner.strategy = :transaction
 
-      raise ActiveRecord::Rollback
-    end
+    DatabaseCleaner.start
+
+    example.run
+
+    DatabaseCleaner.clean
   end
 
   config.around :each, :non_transactional do |example|
-    begin
-      example.run
-    ensure
-      Default.delete_all
-      DefaultWithCounterCache.delete_all
-      DefaultWithCallbacks.delete_all
-      Scoped.delete_all
-    end
+    DatabaseCleaner.strategy = :truncation
+
+    DatabaseCleaner.start
+
+    example.run
+
+    DatabaseCleaner.clean
   end
 end

data/spec/support/db/boot.rb

@@ -0,0 +1,22 @@
+# This script establishes connection, creates DB schema and loads models definitions.
+# Used by both rspec and cucumber
+
+require 'acts_as_ordered_tree'
+require 'active_record'
+
+require 'logger'
+require 'yaml'
+require 'erb'
+
+base_dir = File.dirname(__FILE__)
+config_file = File.join(base_dir, ENV['DBCONF'] || 'config.yml')
+
+ActiveRecord::Base.configurations = YAML::load(ERB.new(IO.read(config_file)).result)
+ActiveRecord::Base.establish_connection(ENV['DB'].to_sym)
+ActiveRecord::Base.logger = Logger.new(ENV['DEBUG'] ? $stderr : '/dev/null')
+ActiveRecord::Migration.verbose = false
+I18n.enforce_available_locales = false if I18n.respond_to?(:enforce_available_locales=)
+
+load(File.join(base_dir, 'schema.rb'))
+
+require File.join(base_dir, '..', 'models')

data/spec/{db → support/db}/config.travis.yml

@@ -2,11 +2,13 @@ pg:
   adapter: postgresql
   username: postgres
   database: acts_as_ordered_tree_test
+  allow_concurrency: true
   min_messages: ERROR
 mysql:
   adapter: mysql2
   database: acts_as_ordered_tree_test
   username: travis
+  password:
   encoding: utf8
 sqlite3:
   adapter: sqlite3

data/spec/{db → support/db}/config.yml

@@ -1,6 +1,7 @@
 pg:
   adapter: postgresql
   database: acts_as_ordered_tree_test
+  allow_concurrency: true
   min_messages: ERROR
 mysql:
   adapter: mysql2

data/spec/{db → support/db}/schema.rb

@@ -20,4 +20,13 @@ ActiveRecord::Schema.define(:version => 0) do
     t.column :parent_id, :integer
     t.column :position, :integer
   end
+
+  create_table :sti_examples, :force => true do |t|
+    t.column :type, :string, :null => false
+    t.column :name, :string
+    t.column :parent_id, :integer
+    t.column :position, :integer
+    t.column :depth, :integer
+    t.column :children_count, :integer
+  end
 end

data/spec/support/factories.rb

@@ -1,5 +1,5 @@
 FactoryGirl.define do
-  factory :default do
+  factory :default, :aliases => [:node] do
     sequence(:name) { |n| "category #{n}" }
   end
 
@@ -7,7 +7,7 @@ FactoryGirl.define do
     sequence(:name) { |n| "category #{n}" }
   end
 
-  factory :default_with_callbacks do
+  factory :default_without_depth do
     sequence(:name) { |n| "category #{n}" }
   end
 

data/spec/support/matchers.rb

@@ -1,14 +1,9 @@
 module RSpec::Matchers
-
-  # it { should fire_callback(:around_move).when_calling(:save) }
-  # it { should fire_callback(:after_move).when_calling(:move_to_left_of, lft_id) }
-  # it { should fire_callback(:around_move).owhen_callingn(:save).at_least(1).time }
-  # it { should fire_callback(:around_move).when_calling(:save).at_most(2).times }
-  # it { should fire_callback(:around_move).when_calling(:save).exactly(2).times }
-  # it { should fire_callback(:around_move).when_calling(:save).once }
-  # it { should fire_callback(:around_move).when_calling(:save).twice }
-  def fire_callback(name)
-    FireCallbackMatcher.new(name)
+  # it { expect{...}.to query_database.once }
+  # it { expect{...}.to query_database.at_most(2).times }
+  # it { expect{...}.not_to query_database }
+  def query_database(regexp = nil)
+    QueryDatabaseMatcher.new(regexp)
   end
 
   # example { expect(record1, record2, record3).to be_sorted }
@@ -16,22 +11,11 @@ module RSpec::Matchers
     OrderMatcher.new
   end
 
-  class FireCallbackMatcher
-    attr_reader :failure_message, :negative_failure_message
-
-    def initialize(callback_name)
-      @callback = callback_name
-      @method = :save
-      @args = []
-
-      @limit_min = 1
-      @limit_max = nil
-    end
-
-    def when_calling(method, *args)
-      @method = method
-      @args = args
-      self
+  class QueryDatabaseMatcher
+    def initialize(regexp)
+      @min = nil
+      @max = nil
+      @regexp = regexp
     end
 
     def times
@@ -40,12 +24,12 @@ module RSpec::Matchers
     alias time times
 
     def at_least(times)
-      @limit_min = times == :once ? 1 : times
+      @min = times == :once ? 1 : times
       self
     end
 
     def at_most(times)
-      @limit_max = times == :once ? 1 : times
+      @max = times == :once ? 1 : times
       self
     end
 
@@ -62,55 +46,80 @@ module RSpec::Matchers
       exactly(2)
     end
 
-    def description
-      "fire callback #@callback when #@method is called"
+    def matches?(subject)
+      record_queries { subject.call }
+
+      result = expected_queries_count.include?(@queries.size)
+      result &&= @queries.any? { |q| @regexp === q } if @regexp
+      result
     end
 
-    def matches?(subject)
-      @subject = subject
+    def description
+      desc = 'query database'
+
+      if @min && !@max
+        desc << ' at least ' << human_readable_count(@min)
+      end
 
-      raise 'Method required' unless @method
+      if @max && !@min
+        desc << ' at most ' << human_readable_count(@max)
+      end
 
-      with_temporary_callback do |ivar|
-        @subject.send(@method, *@args)
+      if @min && @max && @min != @max
+        desc << " #{@min}..#{@max} times"
+      end
 
-        @received = @subject.instance_variable_get ivar
+      if @min && @max && @min == @max
+        desc << ' ' << human_readable_count(@min)
+      end
 
-        (@limit_min..@limit_max || 1000).include?(@received)
+      if @regexp
+        desc << ' and match ' << @regexp.to_s
       end
+
+      desc
     end
 
-    def failure_message_for_should
-      "expected #{@subject.inspect} to fire callback :#@callback when #@method is called (#@limit_min..#@limit_max) times, #@received times fired"
+    def failure_message_for_should(negative = false)
+      verb = negative ? 'not to' : 'to'
+      message = "expected given block #{verb} #{description}, but #{@queries.size} queries sent"
+
+      if @queries.any?
+        message << ":\n#{@queries.each_with_index.map { |q, i| "#{i+1}. #{q}"}.join("\n")}"
+      end
+
+      message
     end
 
     def failure_message_for_should_not
-      "expected #{@subject.inspect} not to fire callback :#@callback when #@method is called (#@limit_min..#@limit_max) times, #@received times fired"
+      failure_message_for_should(true)
+    end
+
+    def supports_block_expectations?
+      true
     end
 
     private
-    def with_temporary_callback
-      kind, name = @callback.to_s.split('_')
+    def record_queries
+      @queries = []
 
-      method_name = :"__temporary_callback_#{object_id.abs}"
+      subscriber = ActiveSupport::Notifications.subscribe('sql.active_record') do |*, sql|
+        next if sql[:name] == 'SCHEMA'
 
-      @subject.class.class_eval <<-CODE
-        def #{method_name}
-          @#{method_name} ||= 0
-          @#{method_name} += 1
-          yield if block_given?
-        end
-        #{kind}_#{name} :#{method_name}
-      CODE
+        @queries << sql[:sql]
+      end
 
-      result = yield :"@#{method_name}"
+      yield
+    ensure
+      ActiveSupport::Notifications.unsubscribe(subscriber)
+    end
 
-      @subject.class.class_eval <<-CODE
-        skip_callback :#{name}, :#{kind}, :#{method_name}
-        undef_method :#{method_name}
-      CODE
+    def expected_queries_count
+      ((@min||1)..@max || 10000)
+    end
 
-      result
+    def human_readable_count(n)
+      n == 1 ? 'once' : "#{n} times"
     end
   end
 
@@ -118,7 +127,7 @@ module RSpec::Matchers
     def matches?(*records)
       @records = Array.wrap(records).flatten
 
-      @records.sort_by { |record| record.reload[record.position_column] } == @records
+      @records.sort_by { |record| record.reload.ordered_tree_node.position } == @records
     end
 
     def failure_message_for_should

data/spec/support/models.rb

@@ -22,22 +22,10 @@ class DefaultWithCounterCache < ActiveRecord::Base
   default_scope { where('1=1') }
 end
 
-class DefaultWithCallbacks < ActiveRecord::Base
+class DefaultWithoutDepth < ActiveRecord::Base
   self.table_name = 'categories'
 
-  acts_as_ordered_tree
-
-  default_scope { where('1=1') }
-
-  after_move     :after_move
-  before_move    :before_move
-  after_reorder  :after_reorder
-  before_reorder :before_reorder
-
-  def after_move; end
-  def before_move; end
-  def after_reorder; end
-  def before_reorder; end
+  acts_as_ordered_tree :depth_column => false
 end
 
 class Scoped < ActiveRecord::Base
@@ -46,4 +34,8 @@ class Scoped < ActiveRecord::Base
   default_scope { where('1=1') }
 
   acts_as_ordered_tree :scope => :scope_type
+end
+
+class StiExample < ActiveRecord::Base
+  acts_as_ordered_tree :counter_cache => :children_count
 end

data/spec/support/tree_factory.rb

@@ -0,0 +1,315 @@
+require 'set'
+
+# @example
+#   describe Something do
+#     tree :factory => :my_model_factory, :attributes => {:scope_type => 'xxx'} do
+#       root {
+#         child_1
+#         child_2 {
+#           child_3 :name => 'a child'
+#         }
+#       }
+#     end
+#
+#     it 'should have root' do
+#       expect(root).to have(2).children
+#     end
+#
+#     it 'should move node' do
+#       child_2.move_higher
+#       expect(current_tree).to match_tree ->{
+#         root {
+#           child_2, :position => 1 do
+#             child_3 :name => 'a child'
+#           end
+#           child_1, :position => 2
+#         }
+#       }
+#     end
+#   end
+module TreeFactory
+  module AbstractNode
+    attr_reader :parent
+    attr_accessor :position
+
+    def children
+      @children ||= []
+    end
+
+    def descendants
+      children.map { |child| [child] + child.descendants }.flatten
+    end
+
+    def self_and_descendants
+      [self] + descendants
+    end
+
+    def parent=(value)
+      @parent = value
+
+      if @parent
+        @parent.children << self
+      end
+    end
+
+    def ancestors
+      parent ? parent.ancestors + [parent] : []
+    end
+
+    def level
+      ancestors.size
+    end
+
+    def indentation
+      ' ' * 2 * level
+    end
+
+    def inspect_attributes
+      attributes.map do |k, v|
+        " / #{k} = #{v}"
+      end.join
+    end
+
+    def inspect_children
+      result = String.new
+
+      if children.any?
+        result << "\n"
+        result << children.map(&:inspect).join("\n")
+      end
+
+      result
+    end
+
+    def matches?(record)
+      record &&
+          record.level == level &&
+          record.ordered_tree_node.position == position &&
+          attributes_matches?(record) &&
+          record.children.size == children.size &&
+          children.zip(record.children).all? { |n, r| n.matches?(r) }
+    end
+
+    def attributes_matches?(record)
+      attributes.all? do |attr, value|
+        if attr.is_a?(Symbol)
+          record.__send__(attr)
+        else
+          record.instance_eval(attr)
+        end == value
+      end
+    end
+  end
+
+  class Node < Struct.new(:name, :attributes)
+    include AbstractNode
+
+    attr_accessor :context
+
+    def inspect
+      if context
+        result = indentation
+        result << record_name
+        result << " / id = #{as_record.id}"
+        result << inspect_attributes
+        result << inspect_children
+        result
+      else
+        super
+      end
+    end
+
+    def matches?(record)
+      record && record == as_record && super
+    end
+
+    private
+    def as_record
+      @record ||= context.__send__(name)
+    end
+
+    def record_name
+      to_s = [:name, :to_str, :to_s].detect { |m| as_record.respond_to?(m) }
+      as_record.__send__(to_s)
+    end
+  end
+
+  class AnyNode < Struct.new(:attributes)
+    include AbstractNode
+
+    def inspect
+      result = indentation
+      result << '*'
+      result << inspect_attributes
+      result << inspect_children
+      result
+    end
+  end
+
+  class Parser
+    attr_reader :ast
+
+    def initialize(options = {})
+      @attributes = options.fetch(:attributes, {})
+      @parent = nil
+    end
+
+    def parse(context, &tree)
+      @ast = []
+      @context = context
+      instance_exec(&tree)
+      ast
+    end
+
+    private
+    def with_parent(parent_node, &block)
+      old, @parent = @parent, parent_node
+      instance_exec(&block) if block_given?
+    ensure
+      @parent = old
+    end
+
+    def node(name, attributes = {}, &block)
+      build_node(block) do
+        Node.new(name.to_sym, @attributes.merge(attributes))
+            .tap { |x| x.context = @context }
+      end
+    end
+
+    def any(attributes = {}, &block)
+      build_node(block) { AnyNode.new(@attributes.merge(attributes)) }
+    end
+
+    def method_missing(name, attributes = {}, &block)
+      node(name, attributes, &block)
+    end
+
+    def build_node(children_block)
+      node = yield
+
+      node.parent = @parent
+
+      if node.parent
+        node.position = node.parent.children.size
+      else
+        @ast << node
+        node.position = @ast.size
+      end
+
+      with_parent(node, &children_block)
+    end
+  end
+
+  class Builder
+    attr_reader :factory
+
+    def initialize(test_suite, options)
+      @parser = Parser.new(options)
+      @suite = test_suite
+      @factory = options.fetch(:factory, @suite.described_class.name.underscore)
+    end
+
+    def build(&tree)
+      memoize_nodes_class
+
+      ast = @parser.parse(@suite, &tree)
+      ast.each { |o| build_node(o) }
+    end
+
+    private
+    def build_node(node)
+      factory = @factory
+
+      raise 'Cannot build ANY node in BEFORE section' if node.is_a?(AnyNode)
+
+      @suite.let!(node.name) do
+        parent = node.parent && send(node.parent.name)
+
+        create factory, node.attributes.merge(:parent => parent)
+      end
+
+      node.children.each { |o| build_node(o) }
+    end
+
+    def memoize_nodes_class
+      factory = FactoryGirl.factory_by_name(@factory)
+      @suite.let(:current_tree) { factory.build_class }
+    end
+  end
+
+  # Class level helper
+  def tree(options, &block)
+    Builder.new(self, options).build(&block)
+  end
+
+  def expect_tree_to_match(&block)
+    caller = caller(1).first
+    file, line, * = caller.split(':')
+    location = [file, line].join(':')
+    example = it { expect(current_tree).to match_tree(block) }
+    example.metadata[:location] = location
+    example.metadata[:file_path] = file
+  end
+end
+
+RSpec::Matchers.define :match_tree do |tree|
+  match do |tree_klass|
+    @expected_tree = tree
+    @klass = tree_klass
+
+    ast.zip(@klass.roots).all? { |node, record| node.matches?(record) }
+  end
+
+  failure_message_for_should do |tree_klass|
+    message = "expected actual tree\n\n"
+    message << inspect_actual_tree(tree_klass)
+    message << "\nto match\n\n"
+    message << ast.map(&:inspect).join("\n")
+  end
+
+  def ast
+    @ast ||= TreeFactory::Parser.new.parse(self, &@expected_tree)
+  end
+
+  def attributes_to_expose
+    @attributes_to_expose ||= flatten_ast.each_with_object(Set[:id]) do |node, attrs|
+      attrs.merge(node.attributes.keys)
+    end.to_a
+  end
+
+  def flatten_ast
+    ast.map(&:self_and_descendants).flatten
+  end
+
+  def inspect_actual_tree(tree_klass)
+    result = String.new
+
+    tree_klass.roots.each do |root|
+      root.self_and_descendants.each do |record|
+        result << "#{inspect_record(record)}\n"
+      end
+    end
+
+    result
+  end
+
+  def inspect_record(record)
+    result = String.new
+    result << indentation(record.level)
+    result << record_name(record)
+
+    attributes_to_expose.each do |attr|
+      result << " / #{attr} = #{record.send(attr)}"
+    end
+    result
+  end
+
+  def record_name(record)
+    to_s = [:name, :to_str, :to_s].detect { |m| record.respond_to?(m) }
+    record.send(to_s)
+  end
+
+  def indentation(level)
+    ' ' * level * 2
+  end
+end