redmineup 1.0.2

data/test/acts_as_taggable/rup_acts_as_taggable_test.rb

@@ -0,0 +1,350 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class RupActsAsTaggableTest < ActiveSupport::TestCase
+  def test_available_tags
+    assert_equivalent [tags(:feature), tags(:bug), tags(:error), tags(:question)], Issue.available_tags(Project.first)
+    assert_equivalent [tags(:error), tags(:question)], Issue.available_tags(project: Project.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([Redmineup::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(%w[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({}, Issue.find_options_for_find_tagged_with(''))
+    assert_equal({}, 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
+    Redmineup::ActsAsTaggable::Tagging.table_name = 'categorisations'
+    Redmineup::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
+    Redmineup::ActsAsTaggable::Tagging.table_name = 'taggings'
+    Redmineup::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 Redmineup::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
+    Redmineup::ActsAsTaggable::Tagging.table_name = 'categorisations'
+    Redmineup::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(/taggings/, sql)
+    assert_no_match(/tags/, sql)
+
+    assert_match(/categorisations/, sql)
+    assert_match(/categories/, sql)
+  ensure
+    Redmineup::ActsAsTaggable::Tagging.table_name = 'taggings'
+    Redmineup::ActsAsTaggable::Tag.table_name = 'tags'
+  end
+
+  def test_tag_list_reader
+    assert_equivalent %w[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 %w[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!(:description => "new name", :tag_list => issues(:first_issue).tag_list.to_s)
+    # end
+
+    assert_equivalent %w[error question], issues(:first_issue).tag_list
+  end
+
+  def test_new_tags
+    assert_equivalent %w[error question], issues(:first_issue).tag_list
+    issues(:first_issue).update!(tag_list: "#{issues(:first_issue).tag_list}, One, Two")
+    assert_equivalent %w[error question One Two], issues(:first_issue).tag_list
+  end
+
+  def test_remove_tag
+    assert_equivalent %w[error question], issues(:first_issue).tag_list
+    issues(:first_issue).update!(tag_list: 'error')
+    assert_equivalent ['error'], issues(:first_issue).tag_list
+  end
+
+  def test_remove_and_add_tag
+    assert_equivalent %w[error question], issues(:first_issue).tag_list
+    issues(:first_issue).update!(tag_list: 'question, Beautiful')
+    assert_equivalent %w[question Beautiful], issues(:first_issue).tag_list
+  end
+
+  def test_tags_not_saved_if_validation_fails
+    issue = issues(:first_issue)
+    assert_equivalent %w[error question], issue.tag_list
+
+    issue.stub(:valid?, false) do
+      assert !issue.update(tag_list: 'One, Two')
+    end
+    assert_equivalent %w[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(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(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 %w[question error], Redmineup::ActsAsTaggable::TagList.from(issues(:first_issue).cached_tag_list)
+    issues(:first_issue).update!(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!(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 'Redmineup::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 'Redmineup::ActsAsTaggable::Tag.count' do
+      issues(:first_issue).tag_list.remove('Random')
+      issues(:first_issue).save!
+    end
+  end
+
+  def test_tag_destroyed_when_unused
+    Redmineup::ActsAsTaggable::Tag.destroy_unused = true
+
+    issues(:first_issue).tag_list.add('Random')
+    issues(:first_issue).save!
+
+    assert_difference 'Redmineup::ActsAsTaggable::Tag.count', -1 do
+      issues(:first_issue).tag_list.remove('Random')
+      issues(:first_issue).save!
+    end
+  ensure
+    Redmineup::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 = Redmineup::ActsAsTaggable::TagList.new(%w(error bug))
+  end
+
+  def test_from
+    assert_equal %w(one two three), Redmineup::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 'Redmineup::ActsAsTaggable::Tag.count' do
+      Redmineup::ActsAsTaggable::Tag.find_or_create_with_like_by_name('error')
+    end
+
+    assert_difference 'Redmineup::ActsAsTaggable::Tag.count', 1 do
+      Redmineup::ActsAsTaggable::Tag.find_or_create_with_like_by_name('new_tag')
+    end
+  end
+
+  def test_name_required
+    tag = Redmineup::ActsAsTaggable::Tag.new
+    tag.valid?
+    assert_match /blank/, tag.errors[:name].to_s
+  end
+
+  def test_name_unique
+    tag = Redmineup::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("Redmineup::ActsAsTaggable::Tagging.count", -Redmineup::ActsAsTaggable::Tagging.where(tag_id: tags(:error).id).count) do
+      assert tags(:error).destroy
+    end
+  end
+
+  def test_all_counts
+    assert_tag_counts Redmineup::ActsAsTaggable::Tag.counts, error: 3, feature: 1, bug: 1, question: 3
+  end
+
+  def test_all_counts_with_string_conditions
+    assert_tag_counts Redmineup::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 Redmineup::ActsAsTaggable::Tag.counts(conditions: ['taggings.created_at >= ?', '2015-01-01']),
+      question: 3, error: 2, feature: 1, bug: 1
+  end
+end

data/test/acts_as_taggable/tagging_test.rb

@@ -0,0 +1,15 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+module Redmineup
+  module ActsAsTaggable
+    class TaggingTest < ActiveSupport::TestCase
+      def test_tag
+        assert_equal tags(:error), taggings(:tag_for_error).tag
+      end
+
+      def test_taggable
+        assert_equal issues(:first_issue), taggings(:tag_for_error).taggable
+      end
+    end
+  end
+end

data/test/acts_as_viewed/rup_acts_as_viewed_test.rb

@@ -0,0 +1,47 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class RupActsAsViewedTest < ActiveSupport::TestCase
+  def user
+    users(:jonathan)
+  end
+
+  def issue
+    issues(:first_issue)
+  end
+
+  def test_zero_of_view_count
+    assert_equal issue.view_count, '0(0)'
+  end
+
+  def test_can_view
+    issue.view '127.0.0.1', user
+    assert_equal issue.view_count, '1(1)'
+    # second view change only total count
+    issue.view '127.0.0.1', user
+    assert_equal issue.view_count, '2(1)'
+  end
+
+  def test_viewed_by
+    assert !issue.viewed_by?('127.0.0.1', user)
+    issue.view '127.0.0.1', user
+    assert issue.viewed_by?('127.0.0.1', user)
+  end
+
+  def test_twice_view
+    issue.view '127.0.0.1', user
+    issue.view '127.0.0.1', user
+    assert_equal '2(1)', issue.view_count
+  end
+
+  def test_viewed?
+    assert !issue.viewed?
+    issue.view '127.0.0.1', user
+    assert issue.viewed?
+  end
+
+  def test_find_viewed_by
+    assert_equal [], Issue.find_viewed_by(user)
+    issue.view '127.0.0.1', user
+    assert_equal [issue], Issue.find_viewed_by(user)
+  end
+end

data/test/acts_as_votable/rup_acts_as_votable_test.rb

@@ -0,0 +1,19 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class RupActsAsVotableTest < ActiveSupport::TestCase
+
+  class NotVotable < ActiveRecord::Base; end
+  def test_that_votable_returns_false_unless_included
+    assert_equal NotVotable.votable?, false
+  end
+
+  def test_that_votable_returns_true_if_included
+    assert_equal Votable.votable?, true
+  end
+
+  def test_behaves_like_votable_model
+    assert Voter.create(:name => 'i can vote!')
+    assert VotableCache.create(:name => 'voting model with cache')
+    assert VotableVoter.create(:name => 'i can vote too!')
+  end
+end

data/test/acts_as_votable/rup_acts_as_voter_test.rb

@@ -0,0 +1,14 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class RupActsAsVoterTest < ActiveSupport::TestCase
+
+  class NotVoter < ActiveRecord::Base; end
+  def test_that_voter_returns_false_unless_included
+    assert_equal NotVoter.voter?, false
+  end
+
+  def test_that_voter_returns_true_if_included
+    assert_equal Voter.voter?, true
+    assert_equal VotableVoter.voter?, true
+  end
+end