redmineup 1.0.2

data/test/acts_as_votable/voter_test.rb

@@ -0,0 +1,296 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class VoterTest < ActiveSupport::TestCase
+  def votable
+    votables(:votable)
+  end
+
+  def voter
+    voters(:voter)
+  end
+
+  def votable_cache
+    votable_caches(:votable_cache)
+  end
+
+  def votable_klass
+    votable.class
+  end
+
+  def test_be_voted_on_after_a_voter_has_voted
+    votable.vote_by :voter => voter
+    assert voter.voted_on?(votable)
+    assert voter.voted_for?(votable)
+  end
+
+  def test_not_be_voted_on_if_a_voter_has_not_voted
+    assert !voter.voted_on?(votable)
+  end
+
+  def test_be_voted_on_after_a_voter_has_voted_under_scope
+    votable.vote_by :voter => voter, :vote_scope => 'rank'
+    assert voter.voted_on?(votable, :vote_scope => 'rank')
+  end
+
+  def test_not_be_voted_on_other_scope_after_a_voter_has_voted_under_one_scope
+    votable.vote_by(:voter => voter, :vote_scope => 'rank')
+    assert !voter.voted_on?(votable)
+  end
+
+  def test_be_voted_as_true_when_a_voter_has_voted_true
+    votable.vote_by(:voter => voter)
+    assert voter.voted_as_when_voted_on(votable)
+    assert voter.voted_as_when_voted_for(votable)
+  end
+
+  def test_be_voted_as_true_when_a_voter_has_voted_true_under_scope
+    votable.vote_by(:voter => voter, :vote_scope => 'rank')
+    assert voter.voted_as_when_voted_for(votable, :vote_scope => 'rank')
+  end
+
+  def test_be_voted_as_false_when_a_voter_has_voted_false
+    votable.vote_by(:voter => voter, :vote => false)
+    assert !voter.voted_as_when_voted_for(votable)
+  end
+
+  def test_be_voted_as_false_when_a_voter_has_voted_false_under_scope
+    votable.vote_by(:voter => voter, :vote => false, :vote_scope => 'rank')
+    assert !voter.voted_as_when_voted_for(votable, :vote_scope => 'rank')
+  end
+
+  def test_be_voted_as_nil_when_a_voter_has_never_voted
+    assert_nil voter.voted_as_when_voting_on(votable)
+  end
+
+  def test_be_voted_as_nil_when_a_voter_has_never_voted_under_the_scope
+    votable.vote_by :voter => voter, :vote => false, :vote_scope => 'rank'
+    assert_nil voter.voted_as_when_voting_on(votable)
+  end
+
+  def test_return_true_if_voter_has_voted_true
+    votable.vote_by(:voter => voter)
+    assert voter.voted_up_on?(votable)
+  end
+
+  def test_return_false_if_voter_has_not_voted_true
+    votable.vote_by(:voter => voter, :vote => false)
+    assert !voter.voted_up_on?(votable)
+  end
+
+  def test_return_true_if_the_voter_has_voted_false
+    votable.vote_by(:voter => voter, :vote => false)
+    assert voter.voted_down_on?(votable)
+  end
+
+  def test_return_false_if_the_voter_has_not_voted_false
+    votable.vote_by(:voter => voter, :vote => true)
+    assert !voter.voted_down_on?(votable)
+  end
+
+  def test_provide_reserve_functionality_voter_can_vote_on_votable
+    voter.vote(:votable => votable, :vote => 'bad')
+    assert !voter.voted_as_when_voting_on(votable)
+  end
+
+  def test_allow_the_voter_to_vote_up_a_model
+    voter.vote_up_for(votable)
+    assert_equal votable.get_up_votes.first.voter, voter
+    assert_equal votable.votes_for.up.first.voter, voter
+  end
+
+  def test_allow_the_voter_to_vote_down_a_model
+    voter.vote_down_for(votable)
+    assert_equal votable.get_down_votes.first.voter, voter
+    assert_equal votable.votes_for.down.first.voter, voter
+  end
+
+  def test_allow_the_voter_to_unvote_a_model
+    voter.vote_up_for(votable)
+    voter.unvote_for(votable)
+    assert_equal votable.find_votes_for.size, 0
+    assert_equal votable.votes_for.count, 0
+  end
+
+  def test_get_all_of_the_voters_votes
+    voter.vote_up_for(votable)
+    assert_equal voter.find_votes.size, 1
+    assert_equal voter.votes.up.count, 1
+  end
+
+  def test_get_all_of_the_voters_up_votes
+    voter.vote_up_for(votable)
+    assert_equal voter.find_up_votes.size, 1
+    assert_equal voter.votes.up.count, 1
+  end
+
+  def test_get_all_of_the_voters_down_votes
+    voter.vote_down_for(votable)
+    assert_equal voter.find_down_votes.size, 1
+    assert_equal voter.votes.down.count, 1
+  end
+
+  def test_get_all_of_the_votes_otes_for_a_class
+    votable.vote_by(:voter => voter)
+    votables(:votable2).vote_by(:voter => voter, :vote => false)
+    assert_equal voter.find_votes_for_class(votable_klass).size, 2
+    assert_equal voter.votes.for_type(votable_klass).count, 2
+  end
+
+  def test_get_all_of_the_voters_up_votes_for_a_class
+    votable.vote_by(:voter => voter)
+    votables(:votable2).vote_by(:voter => voter, :vote => false)
+    assert_equal voter.find_up_votes_for_class(votable_klass).size, 1
+    assert_equal voter.votes.up.for_type(votable_klass).count, 1
+  end
+
+  def test_get_all_of_the_voters_down_votes_for_a_class
+    votable.vote_by(:voter => voter)
+    votables(:votable2).vote_by( :voter => voter, :vote => false)
+    assert_equal voter.find_down_votes_for_class(votable_klass).size, 1
+    assert_equal voter.votes.down.for_type(votable_klass).count, 1
+  end
+
+  def test_be_contained_to_instances
+    voter.vote(:votable => votable, :vote => false)
+    voters(:voter2).vote(:votable => votable)
+
+    assert !voter.voted_as_when_voting_on(votable)
+  end
+
+  # describe '#find_voted_items
+
+  def test_returns_objects_that_a_user_has_upvoted_for
+    votable.vote_by(:voter => voter)
+    votables(:votable2).vote_by(:voter => voters(:voter2))
+    assert voter.find_voted_items.include? votable
+    assert_equal voter.find_voted_items.size, 1
+  end
+
+  def test_returns_objects_that_a_user_has_upvoted_for_using_scope
+    votable.vote_by(:voter => voter, :vote_scope => 'rank')
+    votables(:votable2).vote_by(:voter => voters(:voter2), :vote_scope => 'rank')
+    assert voter.find_voted_items(:vote_scope => 'rank').include? votable
+    assert_equal voter.find_voted_items(:vote_scope => 'rank').size, 1
+  end
+
+  def test_returns_objects_that_a_user_has_downvoted_for
+    votable.vote_down(voter)
+    votables(:votable2).vote_down(voters(:voter2))
+    assert voter.find_voted_items.include? votable
+    assert_equal voter.find_voted_items.size, 1
+  end
+
+  def test_returns_objects_that_a_user_has_downvoted_for_using_scope
+    votable.vote_down voter, :vote_scope => 'rank'
+    votables(:votable2).vote_down(voters(:voter2), :vote_scope => 'rank')
+    assert voter.find_voted_items(:vote_scope => 'rank').include? votable
+    assert_equal voter.find_voted_items(:vote_scope => 'rank').size, 1
+  end
+
+  # describe '#find_up_voted_items
+  def test_returns_objects_that_a_user_has_upvoted_for
+    votable.vote_by(:voter => voter)
+    votables(:votable2).vote_by :voter => voters(:voter2)
+    assert voter.find_up_voted_items.include? votable
+    assert_equal voter.find_up_voted_items.size, 1
+    assert voter.find_liked_items.include? votable
+    assert_equal voter.find_liked_items.size, 1
+  end
+
+  def test_returns_objects_that_a_user_has_upvoted_for_using_scope
+    votable.vote_by(:voter => voter, :vote_scope => 'rank')
+    votables(:votable2).vote_by(:voter => voters(:voter2), :vote_scope => 'rank')
+    assert voter.find_up_voted_items(:vote_scope => 'rank').include? votable
+    assert_equal voter.find_up_voted_items(:vote_scope => 'rank').size, 1
+  end
+
+  def test_does_not_return_objects_that_a_user_has_downvoted_for
+    votable.vote_down voter
+    assert_equal voter.find_up_voted_items.size, 0
+  end
+
+  def test_does_not_return_objects_that_a_user_has_downvoted_for_using_scope
+    votable.vote_down voter, :vote_scope => 'rank'
+    assert_equal voter.find_up_voted_items(:vote_scope => 'rank').size, 0
+  end
+
+  # describe '#find_down_voted_items
+
+  def test_does_not_return_objects_that_a_user_has_upvoted_for
+    votable.vote_by :voter => voter
+    assert_equal voter.find_down_voted_items.size, 0
+  end
+
+  def test_does_not_return_objects_that_a_user_has_upvoted_for_using_scope
+    votable.vote_by :voter => voter, :vote_scope => 'rank'
+    assert_equal voter.find_down_voted_items(:vote_scope => 'rank').size, 0
+  end
+
+  def test_returns_objects_that_a_user_has_downvoted_for
+    votable.vote_down voter
+    votables(:votable2).vote_down voters(:voter2)
+    assert voter.find_down_voted_items.include? votable
+    assert_equal voter.find_down_voted_items.size, 1
+    assert voter.find_disliked_items.include? votable
+    assert_equal voter.find_disliked_items.size, 1
+  end
+
+  def test_returns_objects_that_a_user_has_downvoted_for_using_scope
+    votable.vote_down voter, :vote_scope => 'rank'
+    votables(:votable2).vote_down voters(:voter2), :vote_scope => 'rank'
+    assert voter.find_down_voted_items(:vote_scope => 'rank').include? votable
+    assert_equal voter.find_down_voted_items(:vote_scope => 'rank').size, 1
+  end
+
+  # describe '#get_voted
+  def get_voted
+    voter.get_voted(votable.class)
+  end
+
+  def test_returns_objects_of_a_class_that_a_voter_has_voted_for
+    votable.vote_by :voter => voter
+    votables(:votable2).vote_down voter
+    assert get_voted.include? votable
+    assert get_voted.include? votables(:votable2)
+    assert_equal get_voted.size, 2
+  end
+
+  def test_does_not_return_objects_of_a_class_that_a_voter_has_voted_for
+    votable.vote_by :voter => voters(:voter2)
+    votables(:votable2).vote_by :voter => voters(:voter2)
+    assert_equal get_voted.size, 0
+  end
+
+  # describe '#get_up_voted
+
+  def get_up_voted
+    voter.get_up_voted(votable.class)
+  end
+
+  def test_returns_up_voted_items_that_a_voter_has_voted_for
+    votable.vote_by :voter => voter
+    assert get_up_voted.include? votable
+    assert_equal get_up_voted.size, 1
+  end
+
+  def test_does_not_return_down_voted_items_a_voter_has_voted_for
+    votable.vote_down voter
+    assert_equal get_up_voted.size, 0
+  end
+
+  # describe '#get_down_voted
+  def get_down_voted
+    voter.get_down_voted(votable.class)
+  end
+
+  def test_does_not_return_up_voted_items_that_a_voter_has_voted_for
+    votable.vote_by :voter => voter
+    assert_equal get_down_voted.size, 0
+  end
+
+  def test_returns_down_voted_items_a_voter_has_voted_for
+    votable.vote_down voter
+    assert get_down_voted.include? votable
+    assert_equal get_down_voted.size, 1
+  end
+end

data/test/currency_test.rb

@@ -0,0 +1,292 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+module Redmineup
+  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) }
+      Redmineup::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_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_nil Currency.find_by_iso_numeric("non iso 4217 numeric code")
+      assert_nil Currency.find_by_iso_numeric(0)
+    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_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_nil Currency.find("XXX")
+      #test with symbol
+      Currency.unregister(:yyz)
+      assert_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{#<Redmineup::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 @@
+sqlite:
+  adapter: sqlite3
+  database: ':memory:'
+
+mysql:
+  adapter: mysql2
+  database: redmineup_test
+  username: root
+  password: password
+  host: 127.0.0.1
+
+postgresql:
+  adapter: postgresql
+  database: redmineup_test
+  user: postgres
+  password: password
+  host: 127.0.0.1

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/fixtures/issues.yml

@@ -0,0 +1,24 @@
+first_issue:
+  subject: Issue 1 subject
+  description: Some description for the issue
+  user: jonathan
+  author: jonathan
+  project: first_project
+second_issue:
+  subject: Issue 2 subject
+  description: Second issue
+  user: jonathan
+  author: jonathan
+  project: first_project
+third_issue:
+  subject: Issue 3 subject
+  description: Third issue
+  user: sam
+  author: homer
+  project: second_project
+fourth_issue:
+  subject: Issue 4 subject
+  description: Fourth issue
+  user: sam
+  author: sam
+  project: second_project

data/test/fixtures/news.yml

@@ -0,0 +1,8 @@
+first_news:
+  title: News 1 title
+  description: Some description for the news 1
+  author: jonathan
+second_news:
+  title: News 2 title
+  description: Some description for the news 2
+  author: sam

data/test/fixtures/projects.yml

@@ -0,0 +1,10 @@
+first_project:
+  name: Project 1
+  description: Some description for the project 1
+  identifier: project1
+  status: 1
+second_project:
+  name: Project 2
+  description: Some description for the project 2
+  identifier: project2
+  status: 5

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