yeshua_crm 1.0.0

data/lib/yeshua_crm/money_helper.rb

@@ -0,0 +1,65 @@
+require 'action_view'
+
+module YeshuaCrm
+  module MoneyHelper
+
+    def object_price(obj, price_field = :price, options = {})
+      options.merge!({:symbol => true})
+      price_to_currency(obj.try(price_field), obj.currency, options).to_s if obj.respond_to?(:currency)
+    end
+
+    def prices_collection_by_currency(prices_collection, options={})
+      return [] if prices_collection.blank? || prices_collection == 0
+      prices = prices_collection
+      prices.reject!{|k, v| v.to_i == 0} if options[:hide_zeros]
+      prices.collect{|k, v| content_tag(:span, price_to_currency(v, k, :symbol => true), :style => "white-space: nowrap;")}.compact
+    end
+
+    def deal_currency_icon(currency)
+      case currency.to_s.upcase
+      when 'EUR'
+        "icon-money-euro"
+      when 'GBP'
+        "icon-money-pound"
+      when 'JPY'
+        "icon-money-yen"
+      else
+        "icon-money-dollar"
+      end
+    end
+
+    def collection_for_currencies_select(default_currency = 'BRL', major_currencies = %w(BRL USD EUR GBP RUB CHF))
+      currencies = []
+      currencies << default_currency.to_s unless default_currency.blank?
+      currencies |= major_currencies
+      currencies.map do |c|
+        currency = YeshuaCrm::Currency.find(c)
+        ["#{currency.iso_code} (#{currency.symbol})", currency.iso_code] if currency
+      end.compact.uniq
+    end
+
+    def all_currencies
+      Currency.table.inject([]) do |array, (id, attributes)|
+        array ||= []
+        array << ["#{attributes[:name]}" + (attributes[:symbol].blank? ? "" : " (#{attributes[:symbol]})"), attributes[:iso_code]]
+        array
+      end.sort{|x, y| x[0] <=> y[0]}
+    end
+
+    def price_to_currency(price, currency="BRL", options={})
+      return '' if price.blank?
+
+      currency = "BRL" unless currency.is_a?(String)
+      currency = YeshuaCrm::Currency.find(currency)
+
+      return YeshuaCrm::Currency.format(price.to_f, currency, options)# if currency
+      price.to_s
+    end
+
+
+  end
+end
+
+unless ActionView::Base.included_modules.include?(YeshuaCrm::MoneyHelper)
+  ActionView::Base.send(:include, YeshuaCrm::MoneyHelper)
+end

data/lib/yeshua_crm/version.rb

@@ -0,0 +1,3 @@
+module YeshuaCrm
+  VERSION = "1.0.0"
+end

data/test/acts_as_draftable/draft_test.rb

@@ -0,0 +1,29 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+class DraftTest < ActiveSupport::TestCase
+  def test_restore
+    issue = Issue.new(subject: 'some subject', description: 'some description')
+
+    issue.save_draft(current_user)
+    restored_issue = YeshuaCrm::ActsAsDraftable::Draft.find(issue.draft_id).restore
+
+    assert_equal issue.subject, restored_issue.subject
+    assert_equal issue.description, restored_issue.description
+  end
+
+  def test_restore_all
+    first_issue = Issue.new(subject: 'first subject')
+    first_issue.save_draft(current_user)
+    second_issue = Issue.new(subject: 'second subject')
+    second_issue.save_draft(current_user)
+
+    restored_issues = YeshuaCrm::ActsAsDraftable::Draft.restore_all
+    assert_equal [first_issue.subject, second_issue.subject], restored_issues.map(&:subject).sort
+  end
+
+  private
+
+  def current_user
+    users(:sam)
+  end
+end

data/test/acts_as_draftable/rcrm_acts_as_draftable_test.rb

@@ -0,0 +1,185 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+class RcrmActsAsDraftableTest < ActiveSupport::TestCase
+  def test_rcrm_acts_as_draftable_without_arguments
+    assert_nothing_raised do
+      Cell.rcrm_acts_as_draftable
+    end
+  end
+
+  class SomeClass < ActiveRecord::Base; end
+  def test_rcrm_acts_as_draftable_with_parent
+    assert_nothing_raised do
+      News.rcrm_acts_as_draftable(parent: :author)
+    end
+    assert User.new.respond_to?(:drafts)
+  end
+
+  def test_rcrm_acts_as_draftable_with_non_existing_parent
+    assert_raises do
+      Issue.rcrm_acts_as_draftable(parent: :foo)
+    end
+  end
+
+  def test_rcrm_acts_as_draftable_with_non_hash_argument
+    assert_raises do
+      Issue.rcrm_acts_as_draftable('bar')
+    end
+  end
+
+  def test_rcrm_acts_as_draftable_with_invalid_hash_key
+    assert_raises do
+      Issue.rcrm_acts_as_draftable(baz: 'qux')
+    end
+  end
+
+  def test_drafts
+    issue = Issue.new
+    issue.save_draft(current_user)
+
+    assert_equal 1, Issue.drafts(current_user).count
+    assert_equal YeshuaCrm::ActsAsDraftable::Draft, Issue.drafts(current_user).first.class
+  end
+
+  def test_from_draft
+    issue = Issue.new(subject: 'subject')
+    issue.save_draft(current_user)
+
+    issue_from_draft = Issue.from_draft(issue.draft_id)
+
+    assert_equal Issue, issue_from_draft.class
+    assert_equal true, issue_from_draft.new_record?
+    assert_equal issue.draft_id, issue_from_draft.draft_id
+
+    assert_equal issue.subject, issue_from_draft.subject
+  end
+
+  def test_draft_deleted_after_save
+    issue = Issue.new(subject: 'subject')
+    issue.save_draft(current_user)
+
+    issue_from_draft = Issue.from_draft(issue.draft_id)
+
+    assert_difference 'Issue.count', 1 do
+      assert_difference 'YeshuaCrm::ActsAsDraftable::Draft.count', -1 do
+        issue_from_draft.save!
+      end
+    end
+    assert_nil issue_from_draft.draft_id
+  end
+
+  def test_from_draft_with_non_existing_draft_id
+    assert_raises do
+      Issue.from_draft(999)
+    end
+  end
+
+  def test_from_draft_with_wrong_type
+    Cell.rcrm_acts_as_draftable
+
+    cell = Cell.new
+    cell.save_draft(current_user)
+
+    assert_raises do
+      Issue.from_draft(cell.draft_id)
+    end
+  end
+
+  def test_dump_to_draft
+    assert_equal String, Issue.new.dump_to_draft.class
+  end
+
+  def test_load_to_draft
+    attributes = {subject: 'subject', description: 'description'}
+    draft = Issue.new(attributes).dump_to_draft
+
+    issue = Issue.new
+    issue.load_from_draft(draft)
+
+    assert_equal attributes[:subject], issue.subject
+    assert_equal attributes[:description], issue.description
+  end
+
+  def test_save_draft
+    attributes = {subject: 'subject'}
+    issue = Issue.new(attributes)
+
+    assert_difference 'Issue.count', 0 do
+      assert_difference 'YeshuaCrm::ActsAsDraftable::Draft.count', 1 do
+        result = issue.save_draft(current_user)
+        assert_equal true, result
+      end
+    end
+    assert_equal Fixnum, issue.draft_id.class
+
+
+    draft = YeshuaCrm::ActsAsDraftable::Draft.find(issue.draft_id)
+    assert_equal 'Issue', draft.target_type
+    assert_equal current_user.id, draft.user_id
+    assert_equal attributes[:subject], draft.restore.subject
+  end
+
+  def test_save_draft_without_user
+    issue = Issue.new
+
+    assert_difference 'Issue.count', 0 do
+      assert_difference 'YeshuaCrm::ActsAsDraftable::Draft.count', 1 do
+        result = issue.save_draft
+        assert_equal true, result
+      end
+    end
+
+    draft = YeshuaCrm::ActsAsDraftable::Draft.find(issue.draft_id)
+    assert_nil draft.user_id
+  end
+
+  def test_save_draft_with_associations
+    issue = Issue.new(cell: cells(:second_cell))
+    issue.save_draft(current_user)
+
+    draft = YeshuaCrm::ActsAsDraftable::Draft.find(issue.draft_id)
+    assert_equal issue.cell.name, draft.restore.cell.name
+  end
+
+  def test_save_draft_updates_existing_draft
+    issue = Issue.new
+    issue.save_draft(current_user)
+
+    issue.subject = 'changed subject'
+    assert_difference 'Issue.count', 0 do
+      assert_difference 'YeshuaCrm::ActsAsDraftable::Draft.count', 0 do
+        issue.save_draft(current_user)
+      end
+    end
+
+    draft = YeshuaCrm::ActsAsDraftable::Draft.find(issue.draft_id)
+    assert_equal issue.subject, draft.restore.subject
+  end
+
+  def test_save_draft_does_not_save_persisted_model
+    issue = Issue.new
+    issue.save_draft(current_user)
+    issue.save!
+    assert_equal false, issue.save_draft(current_user)
+  end
+
+  def test_update_draft
+    issue = Issue.new(subject: 'subject')
+    issue.save_draft(current_user)
+
+    assert_difference 'Issue.count', 0 do
+      assert_difference 'YeshuaCrm::ActsAsDraftable::Draft.count', 0 do
+        issue.update_draft(current_user, subject: 'updated_subject')
+      end
+    end
+
+    draft = YeshuaCrm::ActsAsDraftable::Draft.find(issue.draft_id)
+    assert_equal issue.subject, draft.restore.subject
+  end
+
+  private
+
+  def current_user
+    users(:sam)
+  end
+end

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([YeshuaCrm::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
+    YeshuaCrm::ActsAsTaggable::Tagging.table_name = "categorisations"
+    YeshuaCrm::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
+    YeshuaCrm::ActsAsTaggable::Tagging.table_name = "taggings"
+    YeshuaCrm::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 YeshuaCrm::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
+    YeshuaCrm::ActsAsTaggable::Tagging.table_name = "categorisations"
+    YeshuaCrm::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
+    YeshuaCrm::ActsAsTaggable::Tagging.table_name = "taggings"
+    YeshuaCrm::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"], YeshuaCrm::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 "YeshuaCrm::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 'YeshuaCrm::ActsAsTaggable::Tag.count' do
+      issues(:first_issue).tag_list.remove("Random")
+      issues(:first_issue).save!
+    end
+  end
+
+  def test_tag_destroyed_when_unused
+    YeshuaCrm::ActsAsTaggable::Tag.destroy_unused = true
+
+    issues(:first_issue).tag_list.add("Random")
+    issues(:first_issue).save!
+
+    assert_difference 'YeshuaCrm::ActsAsTaggable::Tag.count', -1 do
+      issues(:first_issue).tag_list.remove("Random")
+      issues(:first_issue).save!
+    end
+  ensure
+    YeshuaCrm::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 = YeshuaCrm::ActsAsTaggable::TagList.new(%w(error bug))
+  end
+
+  def test_from
+    assert_equal %w(one two three), YeshuaCrm::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