redmine_crm 0.0.43 → 0.0.63

data/test/acts_as_taggable/rcrm_acts_as_taggable_test.rb

@@ -3,76 +3,81 @@ 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(Project.first)
-    assert_equivalent [tags(:error), tags(:question)], Issue.available_tags(:project => Project.first, :limit => 2)
+    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(: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(: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
+    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('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('')
     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_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_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('')
     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::ActsAsTaggable::Tag.new(:name => 'unsaved tag')])
+    assert_equal [], Issue.find_tagged_with([RedmineCrm::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)
+    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)
+    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')
+    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) }
+    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)
+    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])
+    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
@@ -82,10 +87,10 @@ class RcrmActsAsTaggableTest < ActiveSupport::TestCase
   end
 
   def test_find_options_for_find_tagged_with_respects_custom_table_name
-    RedmineCrm::ActsAsTaggable::Tagging.table_name = "categorisations"
-    RedmineCrm::ActsAsTaggable::Tag.table_name = "categories"
+    RedmineCrm::ActsAsTaggable::Tagging.table_name = 'categorisations'
+    RedmineCrm::ActsAsTaggable::Tag.table_name = 'categories'
 
-    options = Issue.find_options_for_find_tagged_with("Hello")
+    options = Issue.find_options_for_find_tagged_with('Hello')
 
     assert_no_match(/ taggings /, options[:joins])
     assert_no_match(/ tags /, options[:joins])
@@ -93,156 +98,156 @@ class RcrmActsAsTaggableTest < ActiveSupport::TestCase
     assert_match(/ categorisations /, options[:joins])
     assert_match(/ categories /, options[:joins])
   ensure
-    RedmineCrm::ActsAsTaggable::Tagging.table_name = "taggings"
-    RedmineCrm::ActsAsTaggable::Tag.table_name = "tags"
+    RedmineCrm::ActsAsTaggable::Tagging.table_name = 'taggings'
+    RedmineCrm::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 })
+      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, 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
+    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
+    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
+    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
+    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
+    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::ActsAsTaggable::Tag.where(:id => [tags(:error), tags(:question)]), Issue.tag_counts(:order => 'count desc', :limit => 2)
+    assert_equivalent RedmineCrm::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
+    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
+    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
+    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
+    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")
+    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
+    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::ActsAsTaggable::Tagging.table_name = "categorisations"
-    RedmineCrm::ActsAsTaggable::Tag.table_name = "categories"
+    RedmineCrm::ActsAsTaggable::Tagging.table_name = 'categorisations'
+    RedmineCrm::ActsAsTaggable::Tag.table_name = 'categories'
 
-    options = Issue.find_options_for_tag_counts(:start_at => 2.weeks.ago, :end_at => Date.today)
+    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_no_match(/taggings/, sql)
+    assert_no_match(/tags/, sql)
 
-    assert_match /categorisations/, sql
-    assert_match /categories/, sql
+    assert_match(/categorisations/, sql)
+    assert_match(/categories/, sql)
   ensure
-    RedmineCrm::ActsAsTaggable::Tagging.table_name = "taggings"
-    RedmineCrm::ActsAsTaggable::Tag.table_name = "tags"
+    RedmineCrm::ActsAsTaggable::Tagging.table_name = 'taggings'
+    RedmineCrm::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
+    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 ["error", "question"], issues(:first_issue).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_attributes!(:description => "new name", :tag_list => issues(:first_issue).tag_list.to_s)
+    #   issues(:first_issue).update!(:description => "new name", :tag_list => issues(:first_issue).tag_list.to_s)
     # end
 
-    assert_equivalent ["error", "question"], issues(:first_issue).tag_list
+    assert_equivalent %w[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
+    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 ["error", "question"], issues(:first_issue).tag_list
-    issues(:first_issue).update_attributes!(:tag_list => "error")
-    assert_equivalent ["error"], issues(:first_issue).tag_list
+    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 ["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
+    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 ["error", "question"], issue.tag_list
+    assert_equivalent %w[error question], issue.tag_list
 
     issue.stub(:valid?, false) do
-      assert !issue.update_attributes(tag_list: "One, Two")
+      assert !issue.update(tag_list: 'One, Two')
     end
-    assert_equivalent ["error", "question"], Issue.find(issue.id).tag_list
+    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')
+    p = Issue.new(description: 'Test')
 
     assert p.tag_list.blank?
-    p.tag_list = "One, Two"
-    assert_equal "One, Two", p.tag_list.to_s
+    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.update(tag_list: nil)
     assert p.tag_list.blank?
 
     assert p.reload.tag_list.blank?
@@ -252,7 +257,7 @@ class RcrmActsAsTaggableTest < ActiveSupport::TestCase
     p = issues(:second_issue)
 
     assert !p.tag_list.blank?
-    assert p.update_attributes(:tag_list => '  ')
+    assert p.update(tag_list: '  ')
     assert p.tag_list.blank?
 
     assert p.reload.tag_list.blank?
@@ -267,7 +272,7 @@ class RcrmActsAsTaggableTest < ActiveSupport::TestCase
   end
 
   def test_instance_tag_counts
-    assert_tag_counts issues(:first_issue).tag_counts, :error => 3, :question => 3
+    assert_tag_counts issues(:first_issue).tag_counts, error: 3, question: 3
   end
 
   def test_tag_list_populated_when_cache_nil
@@ -279,8 +284,8 @@ class RcrmActsAsTaggableTest < ActiveSupport::TestCase
   def test_cached_tag_list_updated
     assert_nil issues(:first_issue).cached_tag_list
     issues(:first_issue).save!
-    assert_equivalent ["question", "error"], RedmineCrm::ActsAsTaggable::TagList.from(issues(:first_issue).cached_tag_list)
-    issues(:first_issue).update_attributes!(:tag_list => "None")
+    assert_equivalent %w[question error], RedmineCrm::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
@@ -290,8 +295,8 @@ class RcrmActsAsTaggableTest < ActiveSupport::TestCase
     # Generate the cached tag list
     issues(:first_issue).save!
 
-    issues(:first_issue).update_attributes!(:tag_list => "")
-    assert_equal "", issues(:first_issue).cached_tag_list
+    issues(:first_issue).update!(tag_list: '')
+    assert_equal '', issues(:first_issue).cached_tag_list
   end
 
   def test_find_tagged_with_using_sti
@@ -300,19 +305,19 @@ class RcrmActsAsTaggableTest < ActiveSupport::TestCase
   end
 
   def test_case_insensitivity
-    assert_difference "RedmineCrm::ActsAsTaggable::Tag.count", 1 do
-      Issue.create!(:description => "Test", :tag_list => "one")
-      Issue.create!(:description => "Test", :tag_list => "One")
+    assert_difference 'RedmineCrm::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")
+    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).tag_list.add('Random')
     issues(:first_issue).save!
 
     assert_no_difference 'RedmineCrm::ActsAsTaggable::Tag.count' do
-      issues(:first_issue).tag_list.remove("Random")
+      issues(:first_issue).tag_list.remove('Random')
       issues(:first_issue).save!
     end
   end
@@ -320,11 +325,11 @@ class RcrmActsAsTaggableTest < ActiveSupport::TestCase
   def test_tag_destroyed_when_unused
     RedmineCrm::ActsAsTaggable::Tag.destroy_unused = true
 
-    issues(:first_issue).tag_list.add("Random")
+    issues(:first_issue).tag_list.add('Random')
     issues(:first_issue).save!
 
     assert_difference 'RedmineCrm::ActsAsTaggable::Tag.count', -1 do
-      issues(:first_issue).tag_list.remove("Random")
+      issues(:first_issue).tag_list.remove('Random')
       issues(:first_issue).save!
     end
   ensure
@@ -340,6 +345,6 @@ class RcrmActsAsTaggableTest < ActiveSupport::TestCase
     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
+    assert_equal %w[question new], issues(:first_issue).reload.all_tags_list
   end
 end

data/test/fixtures/attachments.yml

@@ -0,0 +1,14 @@
+attachment_001:
+  created_on: 2006-07-19 21:07:27 +02:00
+  downloads: 0
+  content_type: text/plain
+  disk_filename: 060719210727_error281.txt
+  disk_directory: "2006/07"
+  container_id: 3
+  digest: b91e08d0cf966d5c6ff411bd8c4cc3a2
+  id: 1
+  container_type: Issue
+  filesize: 28
+  filename: error281.txt
+  author: jonathan
+  description: An attachment

data/test/liquid/drops/attachment_drop_test.rb

@@ -0,0 +1,15 @@
+require File.dirname(__FILE__) + '/../liquid_helper'
+
+module RedmineCrm
+  class AttachmentDropTest < ActiveSupport::TestCase
+    def setup
+      @attachment = attachments(:attachment_001)
+      @user = @attachment.author
+      @liquid_render = LiquidRender.new('attachment' => Liquid::AttachmentDrop.new(@attachment))
+    end
+
+    def test_author
+      assert_equal @user.name, @liquid_render.render('{{ attachment.author.name }}')
+    end
+  end
+end

data/test/liquid/drops/issue_relations_drop_test.rb

@@ -0,0 +1,24 @@
+require File.dirname(__FILE__) + '/../liquid_helper'
+include LiquidHelperMethods
+
+module RedmineCrm
+  class IssueRelationsDropTest < ActiveSupport::TestCase
+    def setup
+      @issue_from = Issue.find_by(subject: 'Issue 3 subject')
+      @issue_to = Issue.find_by(subject: 'Issue 4 subject')
+      @relation = IssueRelation.create!(issue_from: @issue_from, issue_to: @issue_to, relation_type: 'precedes', delay: 1)
+      @liquid_render = LiquidRender.new(
+        'issue' => Liquid::IssueDrop.new(@issue_from)
+      )
+    end
+
+    def test_relation_from_render
+      issues_text = @liquid_render.render('{% for relation in issue.relations_from %} {{relation.issue_from.id}}|{{relation.issue_to.id}}|{{relation.relation_type}}|{{relation.delay}} {% endfor %}')
+      assert_match "#{@issue_from.id}|#{@issue_to.id}|precedes|#{@relation.delay}", issues_text
+    end
+
+    def test_relation_size
+      assert_equal '1', @liquid_render.render('{{ issue.relations_from.size }}')
+    end
+  end
+end

data/test/liquid/drops/issues_drop_test.rb

@@ -29,6 +29,10 @@ module RedmineCrm
     def test_issue_delegated
       assert_equal [@issue.id, @issue.subject, @issue.description].join('|'),
                    @liquid_render.render('{{ issue.id }}|{{ issue.subject }}|{{ issue.description }}')
+
+      assert_not_equal @issue.subject, @liquid_render.render('{% if issue.closed? %}{{issue.subject}}{% endif %}')
+      @issue.closed = true
+      assert_equal @issue.subject, @liquid_render.render('{% if issue.closed? %}{{issue.subject}}{% endif %}')
     end
   end
 end

data/test/liquid/filters/base_filter_test.rb

@@ -52,12 +52,16 @@ module RedmineCrm
       assert_equal '25', @liquid_render.render("{{24.11 | ceil }}")
     end
 
+    def test_big_decimal_filter_patch
+      assert_equal '2.8571', @liquid_render.render("{{ 20 | divided_by: 7.0 | round: 4 }}")
+    end
+
     def test_floor_filter
       assert_equal '24', @liquid_render.render("{{24.99 | floor }}")
     end
 
     def test_currency_filter
-      assert_equal '99,99 RUB', @liquid_render.render("{{99.99 | currency: 'RUB' }}")
+      assert_equal '99,99 ₽', @liquid_render.render("{{99.99 | currency: 'RUB' }}")
     end
   end
 end

data/test/models/attachment.rb

@@ -0,0 +1,3 @@
+class Attachment < ActiveRecord::Base
+  belongs_to :author, :class_name => "User"
+end

data/test/models/issue.rb

@@ -6,9 +6,16 @@ class Issue < ActiveRecord::Base
   belongs_to :user
   belongs_to :author, class_name: 'User'
 
+  has_many :relations_from, class_name: 'IssueRelation', foreign_key: 'issue_from_id', dependent: :delete_all
+  has_many :relations_to, class_name: 'IssueRelation', foreign_key: 'issue_to_id', dependent: :delete_all
+
   rcrm_acts_as_draftable
   rcrm_acts_as_taggable
   rcrm_acts_as_viewed
 
   scope :visible, lambda { where('1=1') }
+
+  def visible?
+    true
+  end
 end

data/test/models/issue_relation.rb

@@ -0,0 +1,10 @@
+require_relative 'issue'
+
+class IssueRelation < ActiveRecord::Base
+  belongs_to :issue_from, :class_name => 'Issue'
+  belongs_to :issue_to, :class_name => 'Issue'
+
+  def other_issue(issue)
+    (self.issue_from_id == issue.id) ? issue_to : issue_from
+  end
+end

data/test/money_helper_test.rb

@@ -5,7 +5,7 @@ class MoneyHelperTest < ActiveSupport::TestCase
 
   def test_price_to_currency
     assert_equal '$3,265.65', price_to_currency(3265.65, 'USD')
-    assert_equal '3.265,65 RUB', price_to_currency(3265.65, 'RUB')
+    assert_equal '3.265,65 ₽', price_to_currency(3265.65, 'RUB')
     assert_equal '3,200.0', price_to_currency(3200, '')
     assert_equal '3,200.0', price_to_currency(3200, 'Foo')
   end

data/test/schema.rb

@@ -1,5 +1,20 @@
 ActiveRecord::Schema.define version: 0 do
 
+  create_table :attachments, force: true do |t|
+    t.integer :container_id
+    t.string :container_type, limit: 30
+    t.string :filename, default: "", null: false
+    t.string :disk_filename, default: "", null: false
+    t.bigint :filesize, default: 0, null: false
+    t.string :content_type, default: ""
+    t.string :digest, limit: 64, default: "", null: false
+    t.integer :downloads, default: 0, null: false
+    t.integer :author_id, default: 0, null: false
+    t.timestamp :created_on
+    t.string :description
+    t.string :disk_directory
+  end
+
   create_table :drafts, force: true do |t|
     t.string :target_type
     t.integer :target_id
@@ -21,12 +36,18 @@ ActiveRecord::Schema.define version: 0 do
     t.column "created_at", :datetime
   end
 
-
   create_table "users", :force => true do |t|
     t.column "name", :string
     t.column "language", :string
   end
 
+  create_table "issue_relations", :force => true do |t|
+    t.column "issue_from_id", :integer
+    t.column "issue_to_id", :integer
+    t.column "relation_type", :string
+    t.column "delay", :integer
+  end
+
   create_table "issues", :force => true do |t|
     t.integer  "project_id"
     t.column "subject", :string

data/test/tags_helper_test.rb

@@ -3,10 +3,10 @@ require File.dirname(__FILE__) + '/test_helper'
 # module RedmineCrm
   class TagsHelperTest < ActiveSupport::TestCase
     include RedmineCrm::TagsHelper
-    
+
     def test_tag_cloud
       cloud_elements = []
-      
+
       tag_cloud Issue.tag_counts, %w(css1 css2 css3 css4) do |tag, css_class|
         cloud_elements << [tag, css_class]
       end
@@ -16,7 +16,7 @@ require File.dirname(__FILE__) + '/test_helper'
       assert cloud_elements.include?([tags(:feature), "css2"])
       assert_equal 4, cloud_elements.size
     end
-    
+
     # def test_tag_cloud_when_no_tags
     #   cloud_elements = []
     #   tag_cloud SpecialIssue.tag_counts, %w(css1) do |tag, css_class|
@@ -26,4 +26,4 @@ require File.dirname(__FILE__) + '/test_helper'
     #   assert_equal 0, cloud_elements.size
     # end
   end
-# end
+# end