redmine_crm 0.0.4

data/lib/redmine_crm/tag.rb

@@ -0,0 +1,82 @@
+module RedmineCrm
+	class Tag < ActiveRecord::Base
+	  has_many :taggings, :dependent => :destroy
+	  
+	  validates_presence_of :name
+	  # validates_uniqueness_of :name
+	  validates :name, :uniqueness => true
+	  validates :name, :presence => true
+	  cattr_accessor :destroy_unused
+	  self.destroy_unused = false
+	  
+	  attr_accessible :name if defined?(ActiveModel::MassAssignmentSecurity)
+	  
+	  # LIKE is used for cross-database case-insensitivity
+	  def self.find_or_create_with_like_by_name(name)
+	    # find(:first, :conditions => ["name LIKE ?", name]) || create(:name => name)
+	    where("name LIKE LOWER(?)", name.downcase).first || create(:name => name)
+	  end
+	  
+	  def ==(object)
+	    super || (object.is_a?(Tag) && name == object.name)
+	  end
+	  
+	  def to_s
+	    name
+	  end
+	  
+	  def count
+	    read_attribute(:count).to_i
+	  end
+	  
+	  class << self
+	    # Calculate the tag counts for all tags.
+	    #  :start_at - Restrict the tags to those created after a certain time
+	    #  :end_at - Restrict the tags to those created before a certain time
+	    #  :conditions - A piece of SQL conditions to add to the query
+	    #  :limit - The maximum number of tags to return
+	    #  :order - A piece of SQL to order by. Eg 'count desc' or 'taggings.created_at desc'
+	    #  :at_least - Exclude tags with a frequency less than the given value
+	    #  :at_most - Exclude tags with a frequency greater than the given value
+	    def counts(options = {})
+	      # find(:all, options_for_counts(options))
+	     opt = options_for_counts(options)
+	     # byebug
+	     select(opt[:select]).where(opt[:conditions]).joins(opt[:joins]).group(opt[:group])
+	    end
+	    
+	    def options_for_counts(options = {})
+	      options.assert_valid_keys :start_at, :end_at, :conditions, :at_least, :at_most, :order, :limit, :joins
+	      options = options.dup
+	      
+	      start_at = sanitize_sql(["#{Tagging.table_name}.created_at >= ?", options.delete(:start_at)]) if options[:start_at]
+	      end_at = sanitize_sql(["#{Tagging.table_name}.created_at <= ?", options.delete(:end_at)]) if options[:end_at]
+	      
+	      conditions = [
+	        (sanitize_sql(options.delete(:conditions)) if options[:conditions]),
+	        start_at,
+	        end_at
+	      ].compact
+	      
+	      conditions = conditions.join(' AND ') if conditions.any?
+	      
+	      joins = ["INNER JOIN #{Tagging.table_name} ON #{Tag.table_name}.id = #{Tagging.table_name}.tag_id"]
+	      joins << options.delete(:joins) if options[:joins]
+	      
+	      at_least  = sanitize_sql(['COUNT(*) >= ?', options.delete(:at_least)]) if options[:at_least]
+	      at_most   = sanitize_sql(['COUNT(*) <= ?', options.delete(:at_most)]) if options[:at_most]
+	      having 		= "COUNT(*) > 0"
+	      having    = [having, at_least, at_most].compact.join(' AND ')
+	      group_by  = "#{Tag.table_name}.id, #{Tag.table_name}.name"
+	      # group_by << " AND #{having}" unless having.blank?
+	      
+	      { :select     => "#{Tag.table_name}.id, #{Tag.table_name}.name, COUNT(*) AS count", 
+	        :joins      => joins.join(" "),
+	        :conditions => conditions,
+	        :group      => group_by,
+	        :having 		=> having
+	      }.update(options)
+	    end
+	  end
+	end
+end

data/lib/redmine_crm/tag_list.rb

@@ -0,0 +1,112 @@
+module RedmineCrm
+	class TagList < Array
+	  cattr_accessor :delimiter
+	  self.delimiter = ','
+	  
+	  def initialize(*args)
+	    add(*args)
+	  end
+	  
+	  # Add tags to the tag_list. Duplicate or blank tags will be ignored.
+	  #
+	  #   tag_list.add("Fun", "Happy")
+	  # 
+	  # Use the <tt>:parse</tt> option to add an unparsed tag string.
+	  #
+	  #   tag_list.add("Fun, Happy", :parse => true)
+	  def add(*names)
+	    extract_and_apply_options!(names)
+	    concat(names)
+	    clean!
+	    self
+	  end
+	  
+	  # Remove specific tags from the tag_list.
+	  # 
+	  #   tag_list.remove("Sad", "Lonely")
+	  #
+	  # Like #add, the <tt>:parse</tt> option can be used to remove multiple tags in a string.
+	  # 
+	  #   tag_list.remove("Sad, Lonely", :parse => true)
+	  def remove(*names)
+	    extract_and_apply_options!(names)
+	    delete_if { |name| names.include?(name) }
+	    self
+	  end
+	  
+	  # Toggle the presence of the given tags.
+	  # If a tag is already in the list it is removed, otherwise it is added.
+	  def toggle(*names)
+	    extract_and_apply_options!(names)
+	    
+	    names.each do |name|
+	      include?(name) ? delete(name) : push(name)
+	    end
+	    
+	    clean! 
+	    self
+	  end
+	  
+	  # Transform the tag_list into a tag string suitable for edting in a form.
+	  # The tags are joined with <tt>TagList.delimiter</tt> and quoted if necessary.
+	  #
+	  #   tag_list = TagList.new("Round", "Square,Cube")
+	  #   tag_list.to_s # 'Round, "Square,Cube"'
+	  def to_s
+	    clean!
+	    
+	    map do |name|
+	      name.include?(delimiter) ? "\"#{name}\"" : name
+	    end.join(delimiter.ends_with?(" ") ? delimiter : "#{delimiter} ")
+	  end
+	  
+	 private
+	  # Remove whitespace, duplicates, and blanks.
+	  def clean!
+	    reject!(&:blank?)
+	    map!(&:strip)
+	    uniq!
+	  end
+	  
+	  def extract_and_apply_options!(args)
+	    options = args.last.is_a?(Hash) ? args.pop : {}
+	    options.assert_valid_keys :parse
+	    
+	    if options[:parse]
+	      args.map! { |a| self.class.from(a) }
+	    end
+	    
+	    args.flatten!
+	  end
+	  
+	  class << self
+	    # Returns a new TagList using the given tag string.
+	    # 
+	    #   tag_list = TagList.from("One , Two,  Three")
+	    #   tag_list # ["One", "Two", "Three"]
+	    def from(source)
+	      tag_list = new
+	      
+	      case source
+	      when Array
+	        tag_list.add(source)
+	      else
+	        string = source.to_s.dup
+	        
+	        # Parse the quoted tags
+	        [
+	          /\s*#{delimiter}\s*(['"])(.*?)\1\s*/,
+	          /^\s*(['"])(.*?)\1\s*#{delimiter}?/
+	        ].each do |re|
+	          string.gsub!(re) { tag_list << $2; "" }
+	        end
+	        
+	        tag_list.add(string.split(delimiter))
+	      end
+	      
+	      tag_list
+	    end
+	  end
+	end
+
+end

data/lib/redmine_crm/tagging.rb

@@ -0,0 +1,20 @@
+module RedmineCrm
+	
+	class Tagging < ActiveRecord::Base #:nodoc:
+	  belongs_to :tag
+	  belongs_to :taggable, :polymorphic => true
+	  
+	  after_destroy :destroy_tag_if_unused
+	  
+	  private
+	  
+	  def destroy_tag_if_unused
+	    if Tag.destroy_unused
+	      if tag.taggings.count.zero?
+	        tag.destroy
+	      end
+	    end
+	  end
+	end
+	
+end

data/lib/redmine_crm/tags_helper.rb

@@ -0,0 +1,15 @@
+module RedmineCrm
+  module TagsHelper
+    # See the README for an example using tag_cloud.
+    def tag_cloud(tags, classes)
+      return if tags.empty?
+      
+      max_count = tags.sort_by(&:count).last.count.to_f
+      
+      tags.each do |tag|
+        index = ((tag.count / max_count) * (classes.size - 1)).round
+        yield tag, classes[index]
+      end
+    end
+  end
+end

data/lib/redmine_crm/version.rb

@@ -0,0 +1,3 @@
+module RedmineCrm
+  VERSION = "0.0.4"
+end

data/redmine_crm.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'redmine_crm/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "redmine_crm"
+  spec.version       = RedmineCrm::VERSION
+  spec.authors       = ["RedmineCRM"]
+  spec.email         = ["support@redminecrm.com"]
+  spec.summary       = %q{plugins for remine}
+  spec.description   = %q{plugins for Redmine}
+  spec.homepage      = ""
+  spec.license       = "GPL2"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest"
+  spec.add_development_dependency "activerecord"
+  spec.add_development_dependency "actionpack"
+  spec.add_development_dependency "sqlite3"
+  spec.add_development_dependency "mysql2"
+  spec.add_development_dependency "activerecord-mysql-adapter"
+  spec.add_development_dependency "pg"
+end

data/test/acts_as_taggable_test.rb

@@ -0,0 +1,384 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class ActsAsTaggableTest < ActiveSupport::TestCase
+  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)])
+    
+    # assert_equivalent [issues(:jonathan_bad_cat), issues(:jonathan_dog), issues(:second_issue)], Issue.find_tagged_with('"Crazy animal" Bad')
+    # assert_equal Issue.find_tagged_with('"Crazy animal" Bad'), Issue.find_tagged_with(['Crazy animal', 'Bad'])
+    # assert_equal Issue.find_tagged_with('"Crazy animal" Bad'), Issue.find_tagged_with([tags(:animal), tags(:bad)])
+  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([RedmineCrm::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
+    RedmineCrm::Tagging.table_name = "categorisations"
+    RedmineCrm::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
+    RedmineCrm::Tagging.table_name = "taggings"
+    RedmineCrm::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
+    # assert_tag_counts Issue.tag_counts, :good => 1, :question => 3, :question => 1, :bad => 1, :animal => 3
+  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
+    
+    # assert_tag_counts Issue.tag_counts(:start_at => Date.new(2006, 8, 12), :end_at => Date.new(2006, 8, 19)), :good => 1, :question => 2, :bad => 1, :question => 1, :animal => 3
+  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 RedmineCrm::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
+    
+    # assert_tag_counts users(:jonathan).issues.tag_counts, :animal => 3, :question => 1, :question => 1, :bad => 1
+    # assert_tag_counts users(:sam).issues.tag_counts, :question => 2, :good => 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_has_many_through
+  #   assert_tag_counts users(:jonathan).magazines.tag_counts, :good => 1
+  # 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
+    RedmineCrm::Tagging.table_name = "categorisations"
+    RedmineCrm::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
+    RedmineCrm::Tagging.table_name = "taggings"
+    RedmineCrm::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_change_case_of_tags
+  #   original_tag_names = issues(:second_issue).tag_list
+  #   issues(:second_issue).update_attributes!(:tag_list => issues(:second_issue).tag_list.to_s.upcase)
+    
+  #   # The new tag list is not uppercase becuase the AR finders are not case-sensitive
+  #   # and find the old tags when re-tagging with the uppercase tags.
+  #   assert_equivalent original_tag_names, issues(:second_issue).reload.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
+    assert_equivalent ["error", "question"], issues(:first_issue).tag_list
+    assert !issues(:first_issue).update_attributes(:tag_list => "One, Two", :description => "")
+    assert_equivalent ["error", "question"], Issue.find(issues(:first_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_used
+  #   issues(:first_issue).save!
+  #   issues(:first_issue).reload
+    
+  #   assert_no_queries do
+  #     assert_equivalent ["error", "question"], issues(:first_issue).tag_list
+  #   end
+  # end
+  
+  def test_cached_tag_list_not_used
+    # Load fixture and column information
+    issues(:first_issue).taggings(:reload)
+    
+    # assert_queries 1 do
+    #   # Tags association will be loaded
+    #   issues(:first_issue).tag_list
+    # end
+  end
+  
+  def test_cached_tag_list_updated
+    assert_nil issues(:first_issue).cached_tag_list
+    issues(:first_issue).save!
+    assert_equivalent ["question", "error"], RedmineCrm::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
+    special_Issue = SpecialIssue.create!(:description => "Test", :tag_list => "Random")
+    
+    assert_equal [special_Issue],  SpecialIssue.find_tagged_with("Random")
+    assert SpecialIssue.find_tagged_with("Random").include?(special_Issue)
+  end
+  
+  # def test_tag_counts_using_sti
+  #   SpecialIssue.create!(:description => "Test", :tag_list => "question")
+  #   assert_tag_counts SpecialIssue.tag_counts, :question => 1
+  # end
+  
+  def test_case_insensitivity
+    assert_difference "RedmineCrm::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 'RedmineCrm::Tag.count' do
+      issues(:first_issue).tag_list.remove("Random")
+      issues(:first_issue).save!
+    end
+  end
+  
+  def test_tag_destroyed_when_unused
+    RedmineCrm::Tag.destroy_unused = true
+    
+    issues(:first_issue).tag_list.add("Random")
+    issues(:first_issue).save!
+    
+    assert_difference 'RedmineCrm::Tag.count', -1 do
+      issues(:first_issue).tag_list.remove("Random")
+      issues(:first_issue).save!
+    end
+  ensure
+    RedmineCrm::Tag.destroy_unused = false
+  end
+end
+
+# class ActsAsTaggableOnSteroidsFormTest < ActiveSupport::TestCase
+#   include ActionView::Helpers::FormHelper
+  
+#   def test_tag_list_contents
+#     fields_for :Issue, issues(:first_issue) do |f|
+#       assert_match issues(:first_issue).tag_list.to_s, f.text_field(:tag_list)
+#     end
+#   end
+# end