redmine_crm 0.0.4

data/test/currency_test.rb

@@ -0,0 +1,292 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+module RedmineCrm
+  class CurrencyTest < ActiveSupport::TestCase
+    FOO = '{ "priority": 1, "iso_code": "FOO", "iso_numeric": "840", "name": "United States Dollar", "symbol": "$", "subunit": "Cent", "subunit_to_unit": 100, "symbol_first": true, "html_entity": "$", "decimal_mark": ".", "thousands_separator": ",", "smallest_denomination": 1 }'
+    def register_foo(opts={})
+      foo_attrs = JSON.parse(FOO, :symbolize_names => true)
+      # Pass an array of attribute names to 'skip' to remove them from the 'FOO'
+      # json before registering foo as a currency.
+      Array(opts[:skip]).each { |attr| foo_attrs.delete(attr) }
+      RedmineCrm::Currency.register(foo_attrs)
+    end
+
+    def unregister_foo
+      Currency.unregister(JSON.parse(FOO, :symbolize_names => true))
+    end
+
+    def test_unknown_currency
+      assert_equal true, (Currency::UnknownCurrency < ArgumentError)
+    end
+
+    def test_matching_by_id
+      register_foo
+      foo = Currency.new(:foo)
+      assert_equal Currency.find(:foo), foo
+      assert_equal Currency.find(:FOO), foo
+      assert_equal Currency.find("foo"), foo
+      assert_equal Currency.find("FOO"), foo
+      unregister_foo
+    end
+
+    def test_nil_unless_matching_given_id
+      assert_equal nil, Currency.find("ZZZ")
+    end
+      
+    class Mock
+      def to_s
+        '208'
+      end
+    end
+
+    def test_matching_by_given_numeric_code
+      assert_equal Currency.find_by_iso_numeric(978), Currency.new(:eur)
+      assert_not_equal Currency.find_by_iso_numeric(208), Currency.new(:eur)
+      assert_equal Currency.find_by_iso_numeric('840'), Currency.new(:usd)
+
+      assert_equal Currency.find_by_iso_numeric(Mock.new), Currency.new(:dkk)
+      assert_not_equal Currency.find_by_iso_numeric(Mock.new), Currency.new(:usd)
+    end
+
+    def test_nil_if_no_currency_has_the_given_num_code
+      assert_equal Currency.find_by_iso_numeric("non iso 4217 numeric code"), nil
+      assert_equal Currency.find_by_iso_numeric(0), nil
+    end
+
+    # .all
+    def test_array_of_currencies
+      assert Currency.all.include?(Currency.new(:usd))
+    end
+
+    def test_include_register_currencies 
+      register_foo
+      assert Currency.all.include?(Currency.new(:foo))
+      unregister_foo
+    end
+
+    def test_sort_by_priority
+      assert_equal Currency.all.first.priority, 1
+    end
+
+    def test_raises_missing_attributes_error_if_no_priority
+      register_foo(:skip => :priority)
+      assert_raises Currency::MissingAttributeError do
+        Currency.all
+      end
+      unregister_foo
+    end
+
+    #.register
+    def test_register_new_currency
+      Currency.register(
+        iso_code: "XXX",
+        name: "Golden Doubloon",
+        symbol: "%",
+        subunit_to_unit: 100
+      )
+      new_currency = Currency.find("XXX")
+      assert_not_equal nil, new_currency
+      assert_equal "Golden Doubloon", new_currency.name
+      assert_equal "%", new_currency.symbol
+      Currency.unregister(iso_code: "XXX")
+    end
+
+    def test_present_iso_code 
+      assert_raises KeyError do
+        Currency.register(name: "New currency")
+      end
+    end
+
+    # .unregister
+    def test_unregister_currency
+      Currency.register(iso_code: "XXX")
+      assert_not_equal nil, Currency.find("XXX")
+      Currency.unregister(iso_code: "XXX")
+      assert_equal nil, Currency.find("XXX")
+    end
+
+    def test_exitred_currency
+      Currency.register(iso_code: "XXX")
+      assert_equal true, Currency.unregister(iso_code: "XXX")
+      assert_equal false, Currency.unregister(iso_code: "XXX")
+    end
+
+    def test_passed_iso_code
+      Currency.register(iso_code: "XXX")
+      Currency.register(iso_code: "YYZ")
+      #test with string
+      Currency.unregister("XXX")
+      assert_equal nil, Currency.find("XXX")
+      #test with symbol
+      Currency.unregister(:yyz)
+      assert_equal nil, Currency.find(:yyz)
+    end
+
+    # .each
+    def test_each_currency_to_block
+      assert_equal true, Currency.respond_to?(:each)
+      currencies = []
+      Currency.each do |currency|
+        currencies.push(currency)
+      end
+
+      assert_equal currencies[0], Currency.all[0]
+      assert_equal currencies[1], Currency.all[1]
+      assert_equal currencies[-1], Currency.all[-1]
+    end
+
+    # enumerable
+    def test_implemants_enumerable
+      assert_equal true, Currency.respond_to?(:all?)
+      assert_equal true, Currency.respond_to?(:each_with_index)
+      assert_equal true, Currency.respond_to?(:map)
+      assert_equal true, Currency.respond_to?(:select)
+      assert_equal true, Currency.respond_to?(:reject)
+    end
+
+    # #initialize
+    def test_lookups_data_from_loading_config
+      currency = Currency.new("USD")
+      assert_equal :usd, currency.id
+      assert_equal 1, currency.priority
+      assert_equal "USD", currency.iso_code
+      assert_equal "840", currency.iso_numeric
+      assert_equal "United States Dollar", currency.name
+      assert_equal ".", currency.decimal_mark
+      assert_equal ".", currency.separator
+      assert_equal ",", currency.thousands_separator
+      assert_equal ",", currency.delimiter
+      assert_equal 1, currency.smallest_denomination
+    end
+
+    def test_raises_with_unknown_currency
+      assert_raises Currency::UnknownCurrency do
+        Currency.new("xxx")
+      end
+    end
+
+    # #<=>
+    def test_compare_by_priority
+      assert Currency.new(:cad) > Currency.new(:usd)
+      assert Currency.new(:usd) < Currency.new(:eur)
+    end
+
+    def test_compares_by_id_with_same_priority
+      Currency.register(iso_code: "ABD", priority: 15)
+      Currency.register(iso_code: "ABC", priority: 15)
+      Currency.register(iso_code: "ABE", priority: 15)
+      abd = Currency.find("ABD")
+      abc = Currency.find("ABC")
+      abe = Currency.find("ABE")
+      assert abd > abc
+      assert abe > abd
+      Currency.unregister("ABD")
+      Currency.unregister("ABC")
+      Currency.unregister("ABE")
+    end
+
+    # when one of the currencies has no 'priority' set
+    def test_compare_by_id
+      Currency.register(iso_code: "ABD") # No priority
+      abd = Currency.find(:abd)
+      usd = Currency.find(:usd)
+      assert abd < usd
+      Currency.unregister(iso_code: "ABD")
+    end
+
+    # "#=="
+    def test_strong_equal
+      eur = Currency.new(:eur)
+      assert eur === eur
+    end
+
+    def test_equal_id_in_different_case
+      assert_equal Currency.new(:eur), Currency.new(:eur)
+      assert_equal Currency.new(:eur), Currency.new(:EUR)
+      assert_not_equal Currency.new(:eur), Currency.new(:usd)
+    end
+
+    def test_direct_comparison_currency_and_symbol_string
+      assert_equal Currency.new(:eur), 'eur'
+      assert_equal Currency.new(:eur), 'EUR'
+      assert_equal Currency.new(:eur), :eur
+      assert_equal Currency.new(:eur), :EUR
+      assert_not_equal Currency.new(:eur), 'usd'
+    end
+
+    def test_comparison_with_nil
+      assert_not_equal nil, Currency.new(:eur)
+    end
+
+    #eql?
+    def test_eql
+      assert Currency.new(:eur).eql?(Currency.new(:eur))
+      assert !Currency.new(:eur).eql?(Currency.new(:usd))
+    end
+
+    # hash
+    def test_return_same_value_for_equal_objects
+      assert_equal Currency.new(:eur).hash, Currency.new(:eur).hash
+      assert_not_equal Currency.new(:eur).hash, Currency.new(:usd).hash
+    end
+
+    def test_return_intersection_for_array_of_object
+      intersection = [Currency.new(:eur), Currency.new(:usd)] & [Currency.new(:eur)]
+      assert_equal intersection, [Currency.new(:eur)]
+    end
+
+    # inspect
+    def test_work_as_documented
+      assert_equal Currency.new(:usd).inspect, %Q{#<RedmineCrm::Currency id: usd, priority: 1, symbol_first: true, thousands_separator: ,, html_entity: $, decimal_mark: ., name: United States Dollar, symbol: $, subunit_to_unit: 100, exponent: 2.0, iso_code: USD, iso_numeric: 840, subunit: Cent, smallest_denomination: 1>}
+    end
+
+    # to_s
+    def test_to_s
+      assert_equal Currency.new(:usd).to_s, "USD"
+      assert_equal Currency.new(:eur).to_s, "EUR"
+    end
+
+    def test_to_sym
+      assert_equal Currency.new(:usd).to_sym, :USD
+      assert_equal Currency.new(:eur).to_sym, :EUR
+    end
+
+    #  to_currency
+    def test_to_currency
+      usd = Currency.new(:usd)
+      assert_equal usd.to_currency, usd
+    end
+
+    def test_doesnt_create_new_symbol_indefiniteily
+      assert_raises Currency::UnknownCurrency do
+        Currency.new("bogus")
+      end
+      assert !Symbol.all_symbols.map{|s| s.to_s}.include?("bogus")
+    end
+
+    # code
+    def test_code_as_documented
+      assert_equal Currency.new(:usd).code, "$"
+      assert_equal Currency.new(:azn).code, "\u20BC"
+    end
+
+    # exponent
+    def test_conform_to_iso_4217
+      assert Currency.new(:jpy).exponent == 0
+      assert Currency.new(:usd).exponent == 2
+      assert Currency.new(:iqd).exponent == 3
+    end
+
+    # decimal_places
+    def test_proper_place_for_know_currency
+      assert Currency.new(:mro).decimal_places == 1
+      assert Currency.new(:usd).decimal_places == 2
+    end
+
+    def test_proper_place_for_custom_currency
+      register_foo
+      assert_equal 2, Currency.new(:foo).decimal_places
+      unregister_foo
+    end
+  end
+end

data/test/database.yml

@@ -0,0 +1,17 @@
+mysql:
+  :adapter: mysql2
+  :host: localhost
+  :username: root
+  :password: 1
+  :database: rails_plugin_test
+
+sqlite3:
+  :adapter: sqlite3
+  :database: ':memory:'
+
+postgresql:
+  :adapter: postgresql
+  :database: rails_plugin_test
+  :user: container
+  :password: 1
+  :host: localhost

data/test/fixtures/issue.rb

@@ -0,0 +1,9 @@
+class Issue < ActiveRecord::Base
+  rcrm_acts_as_taggable
+  # default_scope {where(:closed => false)}
+  belongs_to :user
+  validates_presence_of :description
+end
+
+class SpecialIssue < Issue
+end

data/test/fixtures/issues.yml

@@ -0,0 +1,12 @@
+first_issue:
+  description: Some description for the issue
+  user: jonathan
+second_issue:
+  description: Second issue
+  user: jonathan
+third_issue:
+  description: Third issue
+  user: sam
+fourth_issue:
+  description: Fourth issue
+  user: sam

data/test/fixtures/taggings.yml

@@ -0,0 +1,32 @@
+tag_for_error:
+  tag: error
+  taggable: first_issue (Issue)
+  created_at: 2014-01-01
+tag_for_error1:
+  tag: error
+  taggable: second_issue (Issue)
+  created_at: 2015-01-01
+tag_for_error2:
+  tag: error
+  taggable: third_issue (Issue)
+  created_at: 2015-01-01
+tag_for_feature:
+  tag: feature
+  taggable: second_issue (Issue)
+  created_at: 2015-01-01
+tag_for_bug:
+  tag: bug
+  taggable: second_issue (Issue)
+  created_at: 2015-01-01
+tag_for_question1:
+  tag: question
+  taggable: third_issue (Issue)
+  created_at: 2015-01-01
+tag_for_question2:
+  tag: question
+  taggable: first_issue (Issue)
+  created_at: 2015-01-01
+tag_for_question3:
+  tag: question
+  taggable: second_issue (Issue)
+  created_at: 2015-02-01

data/test/fixtures/tags.yml

@@ -0,0 +1,11 @@
+error:
+  name: error
+  
+feature:
+  name: New feature
+  
+bug:
+  name: bug
+  
+question:
+  name: question

data/test/fixtures/user.rb

@@ -0,0 +1,3 @@
+class User < ActiveRecord::Base
+  has_many :issues
+end

data/test/fixtures/users.yml

@@ -0,0 +1,5 @@
+jonathan:
+  name: Jonathan
+  
+sam:
+  name: Sam

data/test/schema.rb

@@ -0,0 +1,25 @@
+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
+  end
+end

data/test/tag_test.rb

@@ -0,0 +1,64 @@
+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 /taken/, 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