yeshoua_crm 1.0.0

data/test/acts_as_taggable/rcrm_acts_as_taggable_test.rb

@@ -0,0 +1,345 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class RcrmActsAsTaggableTest < ActiveSupport::TestCase
+  def test_available_tags
+    assert_equivalent [tags(:feature), tags(:bug), tags(:error), tags(:question)], Issue.available_tags(Cell.first)
+    assert_equivalent [tags(:error), tags(:question)], Issue.available_tags(:cell => Cell.first, :limit => 2)
+  end
+
+  def test_find_related_tags_with
+    assert_equivalent [tags(:feature), tags(:bug), tags(:question)], Issue.find_related_tags("error")
+    assert_equivalent [tags(:feature), tags(:error), tags(:question)], Issue.find_related_tags(tags(:bug))
+    assert_equivalent [tags(:error), tags(:question)], Issue.find_related_tags(["New feature", "bug"])
+    assert_equivalent [tags(:feature), tags(:bug)], Issue.find_related_tags([tags(:error), tags(:question)])
+  end
+
+  def test_find_tagged_with_include_and_order
+    assert_equal issues(:third_issue, :first_issue, :second_issue),  Issue.find_tagged_with("question", :order => "issues.description DESC", :include => :user).to_a
+  end
+
+  def test_find_related_tags_with_non_existent_tags
+    assert_equal [], Issue.find_related_tags("ABCDEFG")
+    assert_equal [], Issue.find_related_tags(['HIJKLM'])
+  end
+
+  def test_find_related_tags_with_nothing
+    assert_equal [], Issue.find_related_tags("")
+    assert_equal [], Issue.find_related_tags([])
+  end
+
+  def test_find_tagged_with
+    assert_equivalent [issues(:first_issue), issues(:second_issue), issues(:third_issue)], Issue.find_tagged_with('"error"')
+    assert_equal Issue.find_tagged_with('"error"'), Issue.find_tagged_with(['error'])
+    assert_equal Issue.find_tagged_with('"error"'), Issue.find_tagged_with([tags(:error)])
+
+    assert_equivalent [issues(:second_issue),], Issue.find_tagged_with('New feature')
+    assert_equal Issue.find_tagged_with('New feature'), Issue.find_tagged_with(['New feature'])
+    assert_equal Issue.find_tagged_with('New feature'), Issue.find_tagged_with([tags(:feature)])
+  end
+
+  def test_find_tagged_with_nothing
+    assert_equal [], Issue.find_tagged_with("")
+    assert_equal [], Issue.find_tagged_with([])
+  end
+
+  def test_find_tagged_with_nonexistant_tags
+    assert_equal [], Issue.find_tagged_with('ABCDEFG')
+    assert_equal [], Issue.find_tagged_with(['HIJKLM'])
+    assert_equal [], Issue.find_tagged_with([YeshouaCrm::ActsAsTaggable::Tag.new(:name => 'unsaved tag')])
+  end
+
+  def test_find_tagged_with_match_all
+    assert_equivalent [issues(:second_issue)], Issue.find_tagged_with('error, "bug", "New feature", "question"', :match_all => true)
+  end
+
+  def test_find_tagged_with_match_all_and_include
+    assert_equivalent [issues(:first_issue), issues(:second_issue), issues(:third_issue)], Issue.find_tagged_with(['error', 'question'], :match_all => true, :include => :tags)
+  end
+
+  def test_find_tagged_with_conditions
+    assert_equal [], Issue.find_tagged_with('"error", bug', :conditions => '1=0')
+  end
+
+  def test_find_tagged_with_duplicates_options_hash
+    options = { :conditions => '1=1' }.freeze
+    assert_nothing_raised { Issue.find_tagged_with("error", options) }
+  end
+
+  def test_find_tagged_with_exclusions
+    assert_equivalent [issues(:first_issue), issues(:third_issue)], Issue.find_tagged_with("bug", :exclude => true)
+    assert_equivalent [issues(:first_issue), issues(:third_issue)], Issue.find_tagged_with("'bug', feature", :exclude => true)
+  end
+
+  def test_find_options_for_find_tagged_with_no_tags_returns_empty_hash
+    assert_equal Hash.new, Issue.find_options_for_find_tagged_with("")
+    assert_equal Hash.new, Issue.find_options_for_find_tagged_with([nil])
+  end
+
+  def test_find_options_for_find_tagged_with_leaves_arguments_unchanged
+    original_tags = issues(:second_issue).tags.dup
+    Issue.find_options_for_find_tagged_with(issues(:second_issue).tags)
+    assert_equal original_tags, issues(:second_issue).tags
+  end
+
+  def test_find_options_for_find_tagged_with_respects_custom_table_name
+    YeshouaCrm::ActsAsTaggable::Tagging.table_name = "categorisations"
+    YeshouaCrm::ActsAsTaggable::Tag.table_name = "categories"
+
+    options = Issue.find_options_for_find_tagged_with("Hello")
+
+    assert_no_match(/ taggings /, options[:joins])
+    assert_no_match(/ tags /, options[:joins])
+
+    assert_match(/ categorisations /, options[:joins])
+    assert_match(/ categories /, options[:joins])
+  ensure
+    YeshouaCrm::ActsAsTaggable::Tagging.table_name = "taggings"
+    YeshouaCrm::ActsAsTaggable::Tag.table_name = "tags"
+  end
+
+  def test_include_tags_on_find_tagged_with
+    assert_nothing_raised do
+      Issue.find_tagged_with('error', :include => :tags)
+      Issue.find_tagged_with("error", :include => { :taggings => :tag })
+    end
+  end
+
+  def test_basic_tag_counts_on_class
+    assert_tag_counts Issue.tag_counts, :error => 3, :feature => 1, :question => 3, :bug => 1
+  end
+
+  def test_tag_counts_on_class_with_date_conditions
+    assert_tag_counts Issue.tag_counts(:start_at => Date.new(2015, 1, 1)), :error => 2, :feature => 1, :question => 3, :bug => 1
+    assert_tag_counts Issue.tag_counts(:end_at => Date.new(2014, 12, 31)), :error => 1
+    assert_tag_counts Issue.tag_counts(:start_at => Date.new(2015, 1, 31), :end_at => Date.new(2015, 3, 1)), :question => 1
+  end
+
+  def test_tag_counts_on_class_with_frequencies
+    assert_tag_counts Issue.tag_counts(:at_least => 2), :question => 3, :error => 3
+    assert_tag_counts Issue.tag_counts(:at_most => 2), :bug => 1, :feature => 1
+  end
+
+  def test_tag_counts_on_class_with_frequencies_and_conditions
+    assert_tag_counts Issue.tag_counts(:at_least => 2, :conditions => '1=1'), :question => 3, :error => 3
+  end
+
+  def test_tag_counts_duplicates_options_hash
+    options = { :at_least => 2, :conditions => '1=1' }.freeze
+    assert_nothing_raised { Issue.tag_counts(options) }
+  end
+
+  def test_tag_counts_with_limit
+    assert_equal 2, Issue.tag_counts(:limit => 2).to_a.size
+    assert_equal 2, Issue.tag_counts(:at_least => 3, :limit => 2).to_a.size
+  end
+
+  def test_tag_counts_with_limit_and_order
+    assert_equivalent YeshouaCrm::ActsAsTaggable::Tag.where(:id => [tags(:error), tags(:question)]), Issue.tag_counts(:order => 'count desc', :limit => 2)
+  end
+
+  def test_tag_counts_on_association
+    assert_tag_counts users(:jonathan).issues.tag_counts, :error => 2, :bug => 1, :question => 2, :feature => 1
+    assert_tag_counts users(:sam).issues.tag_counts, :error => 1, :question => 1
+  end
+
+  def test_tag_counts_on_association_with_options
+    assert_equal [], users(:jonathan).issues.tag_counts(:conditions => '1=0')
+    assert_tag_counts users(:jonathan).issues.tag_counts(:at_most => 2), :bug => 1,
+      :feature => 1, :error => 2, :question => 2
+  end
+
+  def test_tag_counts_on_model_instance
+    assert_tag_counts issues(:third_issue).tag_counts, :error => 3, :question => 3
+  end
+
+  def test_tag_counts_on_model_instance_merges_conditions
+    assert_tag_counts issues(:first_issue).tag_counts(:conditions => "tags.name = 'error'"), :error => 3
+  end
+
+  def test_tag_counts_on_model_instance_with_no_tags
+    issue = Issue.create!(:description => "desc")
+
+    assert_tag_counts issue.tag_counts, {}
+  end
+
+  def test_tag_counts_should_sanitize_scope_conditions
+    Issue.send :where, { "tags.id = ?" => tags(:error).id } do
+      assert_tag_counts Issue.tag_counts, :error => 3
+    end
+  end
+
+  def test_tag_counts_respects_custom_table_names
+    YeshouaCrm::ActsAsTaggable::Tagging.table_name = "categorisations"
+    YeshouaCrm::ActsAsTaggable::Tag.table_name = "categories"
+
+    options = Issue.find_options_for_tag_counts(:start_at => 2.weeks.ago, :end_at => Date.today)
+    sql = options.values.join(' ')
+
+    assert_no_match %r{taggings}, sql
+    assert_no_match %r{tags}, sql
+
+    assert_match /categorisations/, sql
+    assert_match /categories/, sql
+  ensure
+    YeshouaCrm::ActsAsTaggable::Tagging.table_name = "taggings"
+    YeshouaCrm::ActsAsTaggable::Tag.table_name = "tags"
+  end
+
+  def test_tag_list_reader
+    assert_equivalent ["error", "question"], issues(:first_issue).tag_list
+    assert_equivalent ["error", "New feature", "bug", "question"], issues(:second_issue).tag_list
+  end
+
+  def test_reassign_tag_list
+    assert_equivalent ["error", "question"], issues(:first_issue).tag_list
+    issues(:first_issue).taggings.reload
+
+    # Only an update of the issues table should be executed, the other two queries are for savepoints
+    # assert_queries 3 do
+    #   issues(:first_issue).update_attributes!(:description => "new name", :tag_list => issues(:first_issue).tag_list.to_s)
+    # end
+
+    assert_equivalent ["error", "question"], issues(:first_issue).tag_list
+  end
+
+  def test_new_tags
+    assert_equivalent ["error", "question"], issues(:first_issue).tag_list
+    issues(:first_issue).update_attributes!(:tag_list => "#{issues(:first_issue).tag_list}, One, Two")
+    assert_equivalent ["error", "question", "One", "Two"], issues(:first_issue).tag_list
+  end
+
+  def test_remove_tag
+    assert_equivalent ["error", "question"], issues(:first_issue).tag_list
+    issues(:first_issue).update_attributes!(:tag_list => "error")
+    assert_equivalent ["error"], issues(:first_issue).tag_list
+  end
+
+  def test_remove_and_add_tag
+    assert_equivalent ["error", "question"], issues(:first_issue).tag_list
+    issues(:first_issue).update_attributes!(:tag_list => "question, Beautiful")
+    assert_equivalent ["question", "Beautiful"], issues(:first_issue).tag_list
+  end
+
+  def test_tags_not_saved_if_validation_fails
+    issue = issues(:first_issue)
+    assert_equivalent ["error", "question"], issue.tag_list
+
+    issue.stub(:valid?, false) do
+      assert !issue.update_attributes(tag_list: "One, Two")
+    end
+    assert_equivalent ["error", "question"], Issue.find(issue.id).tag_list
+  end
+
+  def test_tag_list_accessors_on_new_record
+    p = Issue.new(:description => 'Test')
+
+    assert p.tag_list.blank?
+    p.tag_list = "One, Two"
+    assert_equal "One, Two", p.tag_list.to_s
+  end
+
+  def test_clear_tag_list_with_nil
+    p = issues(:second_issue)
+
+    assert !p.tag_list.blank?
+    assert p.update_attributes(:tag_list => nil)
+    assert p.tag_list.blank?
+
+    assert p.reload.tag_list.blank?
+  end
+
+  def test_clear_tag_list_with_string
+    p = issues(:second_issue)
+
+    assert !p.tag_list.blank?
+    assert p.update_attributes(:tag_list => '  ')
+    assert p.tag_list.blank?
+
+    assert p.reload.tag_list.blank?
+  end
+
+  def test_tag_list_reset_on_reload
+    p = issues(:second_issue)
+    assert !p.tag_list.blank?
+    p.tag_list = nil
+    assert p.tag_list.blank?
+    assert !p.reload.tag_list.blank?
+  end
+
+  def test_instance_tag_counts
+    assert_tag_counts issues(:first_issue).tag_counts, :error => 3, :question => 3
+  end
+
+  def test_tag_list_populated_when_cache_nil
+    assert_nil issues(:first_issue).cached_tag_list
+    issues(:first_issue).save!
+    assert_equal issues(:first_issue).tag_list.to_s, issues(:first_issue).cached_tag_list
+  end
+
+  def test_cached_tag_list_updated
+    assert_nil issues(:first_issue).cached_tag_list
+    issues(:first_issue).save!
+    assert_equivalent ["question", "error"], YeshouaCrm::ActsAsTaggable::TagList.from(issues(:first_issue).cached_tag_list)
+    issues(:first_issue).update_attributes!(:tag_list => "None")
+
+    assert_equal 'None', issues(:first_issue).cached_tag_list
+    assert_equal 'None', issues(:first_issue).reload.cached_tag_list
+  end
+
+  def test_clearing_cached_tag_list
+    # Generate the cached tag list
+    issues(:first_issue).save!
+
+    issues(:first_issue).update_attributes!(:tag_list => "")
+    assert_equal "", issues(:first_issue).cached_tag_list
+  end
+
+  def test_find_tagged_with_using_sti
+    issue = Issue.create!(description: 'Test', tag_list: 'Random')
+    assert_equal [issue], Issue.find_tagged_with('Random')
+  end
+
+  def test_case_insensitivity
+    assert_difference "YeshouaCrm::ActsAsTaggable::Tag.count", 1 do
+      Issue.create!(:description => "Test", :tag_list => "one")
+      Issue.create!(:description => "Test", :tag_list => "One")
+    end
+    assert_equal Issue.find_tagged_with("question"), Issue.find_tagged_with("question")
+  end
+
+  def test_tag_not_destroyed_when_unused
+    issues(:first_issue).tag_list.add("Random")
+    issues(:first_issue).save!
+
+    assert_no_difference 'YeshouaCrm::ActsAsTaggable::Tag.count' do
+      issues(:first_issue).tag_list.remove("Random")
+      issues(:first_issue).save!
+    end
+  end
+
+  def test_tag_destroyed_when_unused
+    YeshouaCrm::ActsAsTaggable::Tag.destroy_unused = true
+
+    issues(:first_issue).tag_list.add("Random")
+    issues(:first_issue).save!
+
+    assert_difference 'YeshouaCrm::ActsAsTaggable::Tag.count', -1 do
+      issues(:first_issue).tag_list.remove("Random")
+      issues(:first_issue).save!
+    end
+  ensure
+    YeshouaCrm::ActsAsTaggable::Tag.destroy_unused = false
+  end
+
+  def test_tags_condition
+    assert_equal "(tags_TABLE.name LIKE #{tags(:feature).id} OR tags_TABLE.name LIKE #{tags(:bug).id})",
+                 Issue.send(:tags_condition, [tags(:feature), tags(:bug)], 'tags_TABLE')
+  end
+
+  def test_all_tags_list
+    issues(:first_issue).tag_list.remove('error')
+    issues(:first_issue).tag_list.add('new')
+    issues(:first_issue).save!
+    assert_equal %w(question new), issues(:first_issue).reload.all_tags_list
+  end
+end

data/test/acts_as_taggable/tag_list_test.rb

@@ -0,0 +1,34 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class TagListTest < ActiveSupport::TestCase
+  def setup
+    @tag_list = YeshouaCrm::ActsAsTaggable::TagList.new(%w(error bug))
+  end
+
+  def test_from
+    assert_equal %w(one two three), YeshouaCrm::ActsAsTaggable::TagList.from('one, two, two, three, three, three')
+  end
+
+  def test_add
+    @tag_list.add(['new_tag'])
+    assert_equal %w(error bug new_tag), @tag_list
+  end
+
+  def test_remove
+    @tag_list.remove(['old_tag'])
+    assert_equal %w(error bug), @tag_list
+    @tag_list.remove(['error'])
+    assert_equal %w(bug), @tag_list
+  end
+
+  def test_toggle
+    @tag_list.toggle(['new_tag'])
+    assert_equal %w(error bug new_tag), @tag_list
+    @tag_list.toggle(['error'])
+    assert_equal %w(bug new_tag), @tag_list
+  end
+
+  def test_to_s
+    assert_equal 'error, bug', @tag_list.to_s
+  end
+end

data/test/acts_as_taggable/tag_test.rb

@@ -0,0 +1,72 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class TagTest < ActiveSupport::TestCase
+  def test_find_or_create_with_like_by_name
+    assert_no_difference 'YeshouaCrm::ActsAsTaggable::Tag.count' do
+      YeshouaCrm::ActsAsTaggable::Tag.find_or_create_with_like_by_name('error')
+    end
+
+    assert_difference 'YeshouaCrm::ActsAsTaggable::Tag.count', 1 do
+      YeshouaCrm::ActsAsTaggable::Tag.find_or_create_with_like_by_name('new_tag')
+    end
+  end
+
+  def test_name_required
+    tag = YeshouaCrm::ActsAsTaggable::Tag.new
+    tag.valid?
+    assert_match /blank/, tag.errors[:name].to_s
+  end
+
+  def test_name_unique
+    tag = YeshouaCrm::ActsAsTaggable::Tag.create!(name: 'My tag')
+    tag_with_same_name = tag.dup
+    assert !tag_with_same_name.valid?
+    assert_match /not uniq/, tag_with_same_name.errors[:name].to_s
+  end
+
+  def test_taggings
+    assert_equivalent [taggings(:tag_for_error), taggings(:tag_for_error1), taggings(:tag_for_error2)], tags(:error).taggings
+    assert_equivalent [taggings(:tag_for_question1), taggings(:tag_for_question2), taggings(:tag_for_question3)], tags(:question).taggings
+  end
+
+  def test_to_s
+    assert_equal tags(:error).name, tags(:error).to_s
+  end
+
+  def test_tag_is_equal_to_itself
+    tag = tags(:error)
+    assert_equal tag, tag
+  end
+
+  def test_tag_is_equal_to_tag_with_same_name
+    tag = tags(:error)
+    assert_equal tag, tag.dup
+  end
+
+  def test_tag_is_not_equal_to_tag_with_other_name
+    tag = tags(:error)
+    other_tag = tag.dup
+    other_tag.name = 'not error'
+    assert_not_equal tag, other_tag
+  end
+
+  def test_taggings_removed_when_tag_destroyed
+    assert_difference("YeshouaCrm::ActsAsTaggable::Tagging.count", -YeshouaCrm::ActsAsTaggable::Tagging.where(tag_id: tags(:error).id).count) do
+      assert tags(:error).destroy
+    end
+  end
+
+  def test_all_counts
+    assert_tag_counts YeshouaCrm::ActsAsTaggable::Tag.counts, error: 3, feature: 1, bug: 1, question: 3
+  end
+
+  def test_all_counts_with_string_conditions
+    assert_tag_counts YeshouaCrm::ActsAsTaggable::Tag.counts(conditions: 'taggings.created_at >= \'2015-01-01\''),
+      question: 3, error: 2, feature: 1, bug: 1
+  end
+
+  def test_all_counts_with_array_conditions
+    assert_tag_counts YeshouaCrm::ActsAsTaggable::Tag.counts(conditions: ['taggings.created_at >= ?', '2015-01-01']),
+      question: 3, error: 2, feature: 1, bug: 1
+  end
+end