closure_tree 6.6.0 → 7.0.0

data/spec/matcher_spec.rb

@@ -1,34 +0,0 @@
-require 'spec_helper'
-
-describe 'ClosureTree::Test::Matcher' do
-
-  describe 'be_a_closure_tree' do
-    it { expect(UUIDTag).to be_a_closure_tree }
-    it { expect(User).to be_a_closure_tree }
-    it { expect(Label).to be_a_closure_tree.ordered }
-    it { expect(Metal).to be_a_closure_tree.ordered(:sort_order) }
-    it { expect(MenuItem).to be_a_closure_tree }
-    it { expect(Contract).not_to be_a_closure_tree }
-  end
-
-  describe 'ordered' do
-    it { expect(Label).to be_a_closure_tree.ordered }
-    it { expect(UUIDTag).to be_a_closure_tree.ordered }
-    it { expect(Metal).to be_a_closure_tree.ordered(:sort_order) }
-  end
-
-  describe 'advisory_lock' do
-    it 'should use advisory lock' do
-      expect(User).to be_a_closure_tree.with_advisory_lock
-      expect(Label).to be_a_closure_tree.ordered.with_advisory_lock
-      expect(Metal).to be_a_closure_tree.ordered(:sort_order).with_advisory_lock
-    end
-
-    describe MenuItem do
-      it 'should not use advisory lock' do
-        is_expected.to be_a_closure_tree.without_advisory_lock
-      end
-    end
-  end
-
-end

data/spec/metal_spec.rb

@@ -1,55 +0,0 @@
-require 'spec_helper'
-
-describe Metal do
-  describe '#find_or_create_by_path' do
-    def assert_correctness(grandchild)
-      expect(grandchild).to be_a(Metal)
-      expect(grandchild.description).to eq('slag')
-      child = grandchild.parent
-      expect(child).to be_a(Unobtanium)
-      expect(child.description).to eq('frames')
-      expect(child.value).to eq('child')
-      parent = child.parent
-      expect(parent).to be_a(Adamantium)
-      expect(parent.description).to eq('claws')
-      expect(parent.value).to eq('parent')
-    end
-
-    let(:attr_path) do
-      [
-        {value: 'parent', description: 'claws', metal_type: 'Adamantium'},
-        {value: 'child', description: 'frames', metal_type: 'Unobtanium'},
-        {value: 'grandchild', description: 'slag', metal_type: 'Metal'}
-      ]
-    end
-
-    before do
-      # ensure the correct root is used in find_or_create_by_path:
-      [Metal, Adamantium, Unobtanium].each do |metal|
-        metal.find_or_create_by_path(%w(parent child grandchild))
-      end
-    end if false
-
-    it 'creates children from the proper root' do
-      assert_correctness(Metal.find_or_create_by_path(attr_path))
-    end
-
-    it 'supports STI from the base class' do
-      assert_correctness(Metal.find_or_create_by_path(attr_path))
-    end
-
-    it 'supports STI from a subclass' do
-      parent = Adamantium.create!(value: 'parent', description: 'claws')
-      assert_correctness(parent.find_or_create_by_path(attr_path.last(2)))
-    end
-
-    it 'maintains the current STI subclass if attributes are not specified' do
-      leaf = Unobtanium.find_or_create_by_path(%w(a b c d))
-      expect(leaf).to be_a(Unobtanium)
-      expect(leaf.ancestors.map(&:value)).to eq(%w(c b a))
-      leaf.ancestors.each do |anc|
-        expect(anc).to be_a(Unobtanium)
-      end
-    end
-  end
-end

data/spec/model_spec.rb

@@ -1,9 +0,0 @@
-require 'spec_helper'
-
-describe ClosureTree::Model do
-  describe '#_ct' do
-    it 'should delegate to the Support instance on the class' do
-      expect(Tag.new._ct).to eq(Tag._ct)
-    end
-  end
-end

data/spec/namespace_type_spec.rb

@@ -1,13 +0,0 @@
-require 'spec_helper'
-
-describe Namespace::Type do
-
-  context "class injection" do
-    it "should build hierarchy classname correctly" do
-      expect(Namespace::Type.hierarchy_class.to_s).to eq("Namespace::TypeHierarchy")
-      expect(Namespace::Type._ct.hierarchy_class_name).to eq("Namespace::TypeHierarchy")
-      expect(Namespace::Type._ct.short_hierarchy_class_name).to eq("TypeHierarchy")
-    end
-  end
-
-end

data/spec/parallel_spec.rb

@@ -1,159 +0,0 @@
-require 'spec_helper'
-
-# We don't need to run the expensive parallel tests for every combination of prefix/suffix.
-# Those affect SQL generation, not parallelism.
-# SQLite doesn't support concurrency reliably, either.
-def run_parallel_tests?
-  !sqlite? &&
-    ActiveRecord::Base.table_name_prefix.empty? &&
-    ActiveRecord::Base.table_name_suffix.empty?
-end
-
-def max_threads
-  5
-end
-
-class WorkerBase
-  extend Forwardable
-  attr_reader :name
-  def_delegators :@thread, :join, :wakeup, :status, :to_s
-
-  def log(msg)
-    puts("#{Thread.current}: #{msg}") if ENV['VERBOSE']
-  end
-
-  def initialize(target, name)
-    @target = target
-    @name = name
-    @thread = Thread.new do
-      ActiveRecord::Base.connection_pool.with_connection { before_work } if respond_to? :before_work
-      log 'going to sleep...'
-      sleep
-      log 'woke up...'
-      ActiveRecord::Base.connection_pool.with_connection { work }
-      log 'done.'
-    end
-  end
-end
-
-class FindOrCreateWorker < WorkerBase
-  def work
-    path = [name, :a, :b, :c]
-    log "making #{path}..."
-    t = (@target || Tag).find_or_create_by_path(path)
-    log "made #{t.id}, #{t.ancestry_path}"
-  end
-end
-
-describe 'Concurrent creation' do
-  before :each do
-    @target = nil
-    @iterations = 5
-  end
-
-  def log(msg)
-    puts(msg) if ENV['VERBOSE']
-  end
-
-  def run_workers(worker_class = FindOrCreateWorker)
-    @names = @iterations.times.map { |iter| "iteration ##{iter}" }
-    @names.each do |name|
-      workers = max_threads.times.map { worker_class.new(@target, name) }
-      # Wait for all the threads to get ready:
-      while true
-        unready_workers = workers.select { |ea| ea.status != 'sleep' }
-        if unready_workers.empty?
-          break
-        else
-          log "Not ready to wakeup: #{unready_workers.map { |ea| [ea.to_s, ea.status] }}"
-          sleep(0.1)
-        end
-      end
-      sleep(0.25)
-      # OK, GO!
-      log 'Calling .wakeup on all workers...'
-      workers.each(&:wakeup)
-      sleep(0.25)
-      # Then wait for them to finish:
-      log 'Calling .join on all workers...'
-      workers.each(&:join)
-    end
-    # Ensure we're still connected:
-    ActiveRecord::Base.connection_pool.connection
-  end
-
-  it 'will not create dupes from class methods' do
-    run_workers
-    expect(Tag.roots.collect { |ea| ea.name }).to match_array(@names)
-    # No dupe children:
-    %w(a b c).each do |ea|
-      expect(Tag.where(name: ea).size).to eq(@iterations)
-    end
-  end
-
-  it 'will not create dupes from instance methods' do
-    @target = Tag.create!(name: 'root')
-    run_workers
-    expect(@target.reload.children.collect { |ea| ea.name }).to match_array(@names)
-    expect(Tag.where(name: @names).size).to eq(@iterations)
-    %w(a b c).each do |ea|
-      expect(Tag.where(name: ea).size).to eq(@iterations)
-    end
-  end
-
-  it 'creates dupe roots without advisory locks' do
-    # disable with_advisory_lock:
-    allow(Tag).to receive(:with_advisory_lock) { |_lock_name, &block| block.call }
-    run_workers
-    # duplication from at least one iteration:
-    expect(Tag.where(name: @names).size).to be > @iterations
-  end
-
-  class SiblingPrependerWorker < WorkerBase
-    def before_work
-      @target.reload
-      @sibling = Label.new(name: SecureRandom.hex(10))
-    end
-
-    def work
-      @target.prepend_sibling @sibling
-    end
-  end
-
-  it 'fails to deadlock while simultaneously deleting items from the same hierarchy' do
-    target = User.find_or_create_by_path((1..200).to_a.map { |ea| ea.to_s })
-    emails = target.self_and_ancestors.to_a.map(&:email).shuffle
-    Parallel.map(emails, :in_threads => max_threads) do |email|
-      ActiveRecord::Base.connection_pool.with_connection do
-        User.transaction do
-          log "Destroying #{email}..."
-          User.where(email: email).destroy_all
-        end
-      end
-    end
-    User.connection.reconnect!
-    expect(User.all).to be_empty
-  end
-
-  class SiblingPrependerWorker < WorkerBase
-    def before_work
-      @target.reload
-      @sibling = Label.new(name: SecureRandom.hex(10))
-    end
-
-    def work
-      @target.prepend_sibling @sibling
-    end
-  end
-
-  it 'fails to deadlock from prepending siblings' do
-    @target = Label.find_or_create_by_path %w(root parent)
-    run_workers(SiblingPrependerWorker)
-    children = Label.roots
-    uniq_order_values = children.collect { |ea| ea.order_value }.uniq
-    expect(children.size).to eq(uniq_order_values.size)
-
-    # The only non-root node should be "root":
-    expect(Label.all.select { |ea| ea.root? }).to eq([@target.parent])
-  end
-end if run_parallel_tests?

data/spec/pool_spec.rb

@@ -1,27 +0,0 @@
-require 'spec_helper'
-
-describe 'Configuration' do
-  it 'returns connection to the pool after has_closure_tree setup' do
-    class TypeDuplicate < ActiveRecord::Base
-      self.table_name = "namespace_type#{table_name_suffix}"
-      has_closure_tree
-    end
-    expect(ActiveRecord::Base.connection_pool.active_connection?).to be_falsey # +false+ in AR 4, +nil+ in AR 5
-  end
-
-  it 'returns connection to the pool after has_closure_tree setup with order' do
-    class MetalDuplicate < ActiveRecord::Base
-      self.table_name = "#{table_name_prefix}metal#{table_name_suffix}"
-      has_closure_tree order: 'sort_order', name_column: 'value'
-    end
-    expect(ActiveRecord::Base.connection_pool.active_connection?).to be_falsey
-  end
-
-  it 'returns connection to the pool after has_closure_tree_root setup' do
-    class GroupDuplicate < ActiveRecord::Base
-      self.table_name = "#{table_name_prefix}group#{table_name_suffix}"
-      has_closure_tree_root :root_user
-    end
-    expect(ActiveRecord::Base.connection_pool.active_connection?).to be_falsey
-  end
-end

data/spec/spec_helper.rb

@@ -1,24 +0,0 @@
-$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../lib')
-
-ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../../Gemfile', __FILE__)
-require 'bundler/setup' if File.exist?(ENV['BUNDLE_GEMFILE'])
-
-require 'database_cleaner'
-require 'closure_tree/test/matcher'
-require 'tmpdir'
-require 'timecop'
-require 'forwardable'
-require 'parallel'
-begin
-  require 'foreigner'
-rescue LoadError
-  #Foreigner is not needed in ActiveRecord 4.2+
-end
-
-Thread.abort_on_exception = true
-
-Dir['./spec/support/**/*.rb'].sort.each { |f| require f }
-
-RSpec.configure do |config|
-  config.include ClosureTree::Test::Matcher
-end

data/spec/support/database.rb

@@ -1,52 +0,0 @@
-database_folder = "#{File.dirname(__FILE__)}/../db"
-database_adapter = ENV['DB'] ||= 'postgresql'
-
-def sqlite?
-  ENV['DB'] == 'sqlite'
-end
-
-log = Logger.new('db.log')
-log.sev_threshold = Logger::DEBUG
-ActiveRecord::Base.logger = log
-
-ActiveRecord::Migration.verbose = false
-ActiveRecord::Base.table_name_prefix = ENV['DB_PREFIX'].to_s
-ActiveRecord::Base.table_name_suffix = ENV['DB_SUFFIX'].to_s
-
-def db_name
-  @db_name ||= "closure_tree_test_#{rand(1..2**31)}"
-end
-
-ActiveRecord::Base.configurations = YAML::load(ERB.new(IO.read("#{database_folder}/database.yml")).result)
-
-config = ActiveRecord::Base.configurations[database_adapter]
-
-begin
-  case database_adapter
-  when 'sqlite'
-    ActiveRecord::Base.establish_connection(database_adapter.to_sym)
-  when 'mysql'
-    ActiveRecord::Base.establish_connection(config.merge('database' => nil))
-    ActiveRecord::Base.connection.recreate_database(config['database'], {charset: 'utf8', collation: 'utf8_unicode_ci'})
-  when 'postgresql'
-    ActiveRecord::Base.establish_connection(config.merge('database' => 'postgres', 'schema_search_path' => 'public'))
-    ActiveRecord::Base.connection.recreate_database(config['database'], config.merge('encoding' => 'utf8'))
-  end
-end unless ENV['NONUKES']
-
-ActiveRecord::Base.establish_connection(config)
-# Drop this when support for ActiveRecord 4.1 is removed
-Foreigner.load if defined?(Foreigner)
-
-require "#{database_folder}/schema"
-require "#{database_folder}/models"
-
-# See http://stackoverflow.com/a/22388177/1268016
-def count_queries(&block)
-  count = 0
-  counter_fn = ->(name, started, finished, unique_id, payload) do
-    count += 1 unless %w[CACHE SCHEMA].include? payload[:name]
-  end
-  ActiveSupport::Notifications.subscribed(counter_fn, 'sql.active_record', &block)
-  count
-end

data/spec/support/database_cleaner.rb

@@ -1,14 +0,0 @@
-RSpec.configure do |config|
-
-  DatabaseCleaner.strategy = :truncation
-
-  config.before(:each) do
-    ActiveRecord::Base.connection_pool.connection
-    DatabaseCleaner.start
-  end
-
-  config.after(:each) do
-    ActiveRecord::Base.connection_pool.connection
-    DatabaseCleaner.clean
-  end
-end

data/spec/support/exceed_query_limit.rb

@@ -1,18 +0,0 @@
-# Derived from http://stackoverflow.com/a/13423584/153896. Updated for RSpec 3.
-RSpec::Matchers.define :exceed_query_limit do |expected|
-  supports_block_expectations
-
-  match do |block|
-    query_count(&block) > expected
-  end
-
-  failure_message_when_negated do |actual|
-    "Expected to run maximum #{expected} queries, got #{@counter.query_count}"
-  end
-
-  def query_count(&block)
-    @counter = ActiveRecord::QueryCounter.new
-    ActiveSupport::Notifications.subscribed(@counter.to_proc, 'sql.active_record', &block)
-    @counter.query_count
-  end
-end

data/spec/support/hash_monkey_patch.rb

@@ -1,13 +0,0 @@
-class Hash
-  def render_from_yield(&block)
-    reduce({}) do |h, entry|
-      k, v = entry
-      h[block.call(k)] = if v.is_a?(Hash) then
-        v.render_from_yield(&block)
-      else
-        block.call(v)
-      end
-      h
-    end
-  end
-end

data/spec/support/query_counter.rb

@@ -1,18 +0,0 @@
-# From http://stackoverflow.com/a/13423584/153896
-module ActiveRecord
-  class QueryCounter
-    attr_reader :query_count
-
-    def initialize
-      @query_count = 0
-    end
-
-    def to_proc
-      lambda(&method(:callback))
-    end
-
-    def callback(name, start, finish, message_id, values)
-      @query_count += 1 unless %w(CACHE SCHEMA).include?(values[:name])
-    end
-  end
-end