test_redmine_vz 0.0.24

data/test/fixtures/voters.yml

@@ -0,0 +1,6 @@
+voter:
+  name: 'i can vote!'
+voter2:
+  name: 'a new person'
+voter3:
+  name: 'another person'

data/test/liquid_test.rb

@@ -0,0 +1,80 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+module RedmineCrm
+  class LiquidTest < ActiveSupport::TestCase
+    def test_today_filter
+      assert_match Date.today.strftime(date_format), render('{{today}}')
+    end
+
+    def test_plus_days_filter
+      assert_match (Date.today + 3.days).strftime(date_format), render("{{today | plus_days: 3 | date: '#{date_format}'}}")
+    end
+
+    def test_date_range_filter
+      assert_equal '10', render("{{today | date_range: '#{Date.today - 10.days}'}}")
+    end
+
+    # RedCloth3 is a part of Redmine - test will not work
+    # def test_textilize_filter
+    #   assert_match '<h1>Some text</h1>', render("{{ 'Some text' | textilize }}")
+    # end
+
+    def test_underscore_filter
+      assert_match 'some_text', render("{{ 'some text' | underscore }}")
+    end
+
+    def test_dasherize_filter
+      assert_match 'some-text', render("{{ 'some text' | dasherize }}")
+    end
+
+    def test_random_filter
+      assert render("{{ random: 10 }}").to_i <= 10
+    end
+
+    def test_user_drop
+      user = User.first
+      assert_match user.name, render("{{ user.name }}")
+    end
+
+    def test_users_drop
+      users_name = User.all.map(&:name)
+      rendered_text = render("{% for user in users %} {{user.name }} {% endfor %}")
+      users_name.each do |name|
+        assert_match name, rendered_text
+      end
+    end
+
+    def test_issue_drop
+      assert_match Issue.first.description, render("{{ issue.description }}")
+    end
+
+    def test_default_filter
+      user = User.first
+      user.name = nil
+      user.save
+      assert_match 'user', render("{{ user.name | default: 'user' }}")
+    end
+
+    private
+
+    def render(content)
+      assigns = {}
+      assigns['now'] = Time.now
+      assigns['today'] = Date.today.strftime(date_format)
+      assigns['user'] = Liquid::UserDrop.new(User.first)
+      assigns['users'] = Liquid::UsersDrop.new(User.all)
+      assigns['issue'] = Liquid::IssueDrop.new(Issue.first)
+
+      registers = {}
+      begin
+        ::Liquid::Template.parse(content).render(::Liquid::Context.new({}, assigns, registers)).html_safe
+      rescue => e
+        e.message
+      end
+    end
+
+    def date_format
+      '%d.%m.%Y'
+    end
+  end
+end

data/test/money_helper_test.rb

@@ -0,0 +1,12 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class MoneyHelperTest < ActiveSupport::TestCase
+  include RedmineCrm::MoneyHelper
+
+  def test_price_to_currency
+    assert_equal '$3,265.65', price_to_currency(3265.65, "USD")
+    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
+end

data/test/schema.rb

@@ -0,0 +1,100 @@
+ActiveRecord::Schema.define :version => 0 do
+  
+  create_table "tags", :force => true do |t|
+    t.column "name", :string
+  end
+  
+  create_table "taggings", :force => true do |t|
+    t.column "tag_id", :integer
+    t.column "taggable_id", :integer
+    t.column "taggable_type", :string
+    t.column "created_at", :datetime
+  end
+  
+
+  create_table "users", :force => true do |t|
+    t.column "name", :string
+  end
+  
+  create_table "issues", :force => true do |t|
+    t.column "description", :string
+    t.column "closed", :boolean
+    t.column "cached_tag_list", :string
+    t.column "user_id", :integer
+    t.column "views", :integer, :default => 0
+    t.column "total_views", :integer, :default => 0
+  end
+
+  create_table "votes", :force => true do |t|
+    t.references "votable", :polymorphic => true
+    t.references "voter", :polymorphic => true
+
+    t.boolean "vote_flag"
+    t.string "vote_scope"
+    t.integer "vote_weight"
+
+    t.timestamps
+  end
+
+  # add_index :votes, [:votable_id, :votable_type]
+  # add_index :votes, [:voter_id, :voter_type]
+  # add_index :votes, [:voter_id, :voter_type, :vote_scope]
+  # add_index :votes, [:votable_id, :votable_type, :vote_scope]
+
+  create_table :voters, :force => true do |t|
+    t.string :name
+  end
+
+  create_table :not_voters, :force => true do |t|
+    t.string :name
+  end
+
+  create_table :votables, :force => true do |t|
+    t.string :name
+  end
+
+  create_table :votable_voters, :force => true do |t|
+    t.string :name
+  end
+
+  create_table :sti_votables, :force => true do |t|
+    t.string :name
+    t.string :type
+  end
+
+  create_table :sti_not_votables, :force => true do |t|
+    t.string :name
+    t.string :type
+  end
+
+  create_table :not_votables, :force => true do |t|
+    t.string :name
+  end
+
+  create_table :votable_caches, :force => true do |t|
+    t.string :name
+    t.integer :cached_votes_total
+    t.integer :cached_votes_score
+    t.integer :cached_votes_up
+    t.integer :cached_votes_down
+    t.integer :cached_weighted_total
+    t.integer :cached_weighted_score
+    t.float :cached_weighted_average
+
+    t.integer :cached_scoped_test_votes_total
+    t.integer :cached_scoped_test_votes_score
+    t.integer :cached_scoped_test_votes_up
+    t.integer :cached_scoped_test_votes_down
+    t.integer :cached_scoped_weighted_total
+    t.integer :cached_scoped_weighted_score
+    t.float :cached_scoped_weighted_average
+  end
+
+  create_table :viewings, :force => true do |t|
+    t.column :viewer_id,   :integer
+    t.column :viewed_id,   :integer
+    t.column :viewed_type, :string
+    t.column :ip, :string, :limit => '24'
+    t.column :created_at, :datetime
+  end
+end

data/test/tag_test.rb

@@ -0,0 +1,63 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+module RedmineCrm
+  class TagTest < ActiveSupport::TestCase
+    def test_name_required
+      t = Tag.create
+      assert_match /blank/, t.errors[:name].to_s
+    end
+
+    def test_name_unique
+      t = Tag.create!(:name => "My tag")
+      duplicate = t.dup
+      assert !duplicate.save
+      assert_match /not uniq/, duplicate.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_equality
+      assert_equal tags(:error), tags(:error)
+      assert_equal Tag.find(tags(:error).id), Tag.find(tags(:error).id)
+      assert_equal Tag.new(:name => 'A'), Tag.new(:name => 'A')
+      assert_not_equal Tag.new(:name => 'A'), Tag.new(:name => 'B')
+    end
+
+    def test_taggings_removed_when_tag_destroyed
+      assert_difference("Tagging.count", -Tagging.where(:tag_id => tags(:error).id).count) do
+        assert tags(:error).destroy
+      end
+    end
+
+    def test_all_counts
+      assert_tag_counts Tag.counts, :error => 3, :feature => 1, :bug => 1, :question => 3
+    end
+
+    def test_all_counts_with_string_conditions
+      assert_tag_counts 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 Tag.counts(:conditions => ['taggings.created_at >= ?', '2015-01-01']),
+        :question => 3, :error => 2, :feature => 1, :bug => 1
+    end
+
+    def test_all_counts_with_hash_conditions
+      tag_counts = Tag.counts(
+        :conditions => {
+          :taggings => { :created_at => (DateTime.parse('2014-12-31 23:59') .. DateTime.parse('4000-01-01')) }
+        }
+      )
+      assert_tag_counts tag_counts, :question => 3, :error => 2, :feature => 1, :bug => 1
+    end
+  end
+end

data/test/tagging_test.rb

@@ -0,0 +1,14 @@
+require File.dirname(__FILE__) + '/test_helper'
+# require File.dirname(__FILE__) + '/fixtures/issue'
+
+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

data/test/tags_helper_test.rb

@@ -0,0 +1,29 @@
+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
+      assert cloud_elements.include?([tags(:error), "css4"])
+      assert cloud_elements.include?([tags(:question), "css4"])
+      assert cloud_elements.include?([tags(:bug), "css2"])
+      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|
+    #     # assert false, "tag_cloud should not yield"
+    #     cloud_elements << [tag, css_class]
+    #   end
+    #   assert_equal 0, cloud_elements.size
+    # end
+  end
+# end

data/test/test_helper.rb

@@ -0,0 +1,118 @@
+require 'minitest/autorun'
+require 'byebug'
+# require 'test/unit'
+
+begin
+  require File.dirname(__FILE__) + '/../../../../config/environment'
+rescue LoadError
+  require 'rubygems'
+  gem 'activerecord', "4.2.7.1"
+  gem 'actionpack', "4.2.7.1"
+  require 'active_record'
+  # require 'action_controller'
+end
+require "redmine_crm"
+require "active_record/fixtures"
+
+require File.dirname(__FILE__) + '/../lib/redmine_crm/rcrm_acts_as_taggable'
+require File.dirname(__FILE__) + '/../lib/redmine_crm/tag_list'
+require File.dirname(__FILE__) + '/../lib/redmine_crm/tag'
+require File.dirname(__FILE__) + '/../lib/redmine_crm/tagging'
+require File.dirname(__FILE__) + '/../lib/redmine_crm/helpers/tags_helper'
+require File.dirname(__FILE__) + '/../lib/redmine_crm/rcrm_acts_as_votable'
+require File.dirname(__FILE__) + '/../lib/redmine_crm/rcrm_acts_as_voter'
+
+# require_dependency File.dirname(__FILE__) + '/../lib/redmine_crm/tags_helper'
+
+ActiveRecord::Base.logger = Logger.new(File.dirname(__FILE__) + '/debug.log')
+ActiveRecord::Base.configurations = YAML::load(IO.read(File.dirname(__FILE__) + '/database.yml'))
+ActiveRecord::Base.establish_connection(ActiveRecord::Base.configurations[ENV['DB'] || 'sqlite3'])
+
+load(File.dirname(__FILE__) + '/schema.rb')
+load(File.dirname(__FILE__) + '/fixtures/user.rb')
+load(File.dirname(__FILE__) + '/fixtures/issue.rb')
+load(File.dirname(__FILE__) + "/fixtures/vote_classes.rb")
+
+# Dir["/fixtures/*.rb"].each{|file| load file}
+
+class ActiveSupport::TestCase #:nodoc:
+  include ActiveRecord::TestFixtures
+
+  self.fixture_path = File.dirname(__FILE__) + "/fixtures/"
+
+  self.use_transactional_fixtures = true
+  self.use_instantiated_fixtures  = false
+  set_fixture_class :tags => RedmineCrm::Tag
+  set_fixture_class :taggings => RedmineCrm::Tagging
+
+  set_fixture_class :votable_caches => VotableCache
+  fixtures :all
+
+  def assert_equivalent(expected, actual, message = nil)
+    if expected.first.is_a?(ActiveRecord::Base)
+      assert_equal expected.sort_by(&:id), actual.sort_by(&:id), message
+    else
+      assert_equal expected.sort, actual.sort, message
+    end
+  end
+
+  def assert_tag_counts(tags, expected_values)
+    # Map the tag fixture names to real tag names
+    expected_values = expected_values.inject({}) do |hash, (tag, count)|
+      hash[tags(tag).name] = count
+      hash
+    end
+
+    tags.each do |tag|
+      value = expected_values.delete(tag.name)
+
+      assert_not_nil value, "Expected count for #{tag.name} was not provided"
+      assert_equal value, tag.count, "Expected value of #{value} for #{tag.name}, but was #{tag.count}"
+    end
+
+    unless expected_values.empty?
+      assert false, "The following tag counts were not present: #{expected_values.inspect}"
+    end
+  end
+
+  # def assert_queries(num = 1)
+  #   $query_count = 0
+  #   yield
+  # ensure
+  #   assert_equal num, $query_count, "#{$query_count} instead of #{num} queries were executed."
+  # end
+
+  # def assert_queries(num = 1, options = {})
+  #   ignore_none = options.fetch(:ignore_none) { num == :any }
+  #   SQLCounter.clear_log
+  #   yield
+  # ensure
+  #   the_log = ignore_none ? SQLCounter.log_all : SQLCounter.log
+  #   if num == :any
+  #     assert_operator the_log.size, :>=, 1, "1 or more queries expected, but none were executed."
+  #   else
+  #     mesg = "#{the_log.size} instead of #{num} queries were executed.#{the_log.size == 0 ? '' : "\nQueries:\n#{the_log.join("\n")}"}"
+  #     assert_equal num, the_log.size, mesg
+  #   end
+  # end
+
+  def assert_no_queries(&block)
+    assert_queries(0, &block)
+  end
+
+  # From Rails trunk
+  def assert_difference(expressions, difference = 1, message = nil, &block)
+    expression_evaluations = [expressions].flatten.collect{|expression| lambda { eval(expression, block.binding) } }
+
+    original_values = expression_evaluations.inject([]) { |memo, expression| memo << expression.call }
+    yield
+    expression_evaluations.each_with_index do |expression, i|
+      assert_equal original_values[i] + difference, expression.call, message
+    end
+  end
+
+  def assert_no_difference(expressions, message = nil, &block)
+    assert_difference expressions, 0, message, &block
+  end
+
+end

data/test/viewed_test.rb

@@ -0,0 +1,45 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class ViewedTest < ActiveSupport::TestCase
+  
+  def user
+    user = users(:jonathan)
+  end
+
+  def issue
+    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
+
+
+end