← Back to branch summary

~michaelforrest/use-case-mapper/trunk

« back to all changes in this revision

Viewing changes to vendor/rails/activerecord/test/cases/reflection_test.rb

  • Committer: Richard Lee (Canonical)
  • Date: 2010-10-15 15:17:58 UTC
  • mfrom: (190.1.3 use-case-mapper)
  • Revision ID: richard.lee@canonical.com-20101015151758-wcvmfxrexsongf9d
Merge

Show diffs side-by-side

added added

removed removed

Lines of Context:
vendor/rails/activerecord/test/cases/reflection_test.rb
1
 
require "cases/helper"
2
 
require 'models/topic'
3
 
require 'models/customer'
4
 
require 'models/company'
5
 
require 'models/company_in_module'
6
 
require 'models/subscriber'
7
 
require 'models/pirate'
8
 
 
9
 
class ReflectionTest < ActiveRecord::TestCase
10
 
  fixtures :topics, :customers, :companies, :subscribers
11
 
 
12
 
  def setup
13
 
    @first = Topic.find(1)
14
 
  end
15
 
 
16
 
  def test_column_null_not_null
17
 
    subscriber = Subscriber.find(:first)
18
 
    assert subscriber.column_for_attribute("name").null
19
 
    assert !subscriber.column_for_attribute("nick").null
20
 
  end
21
 
 
22
 
  def test_read_attribute_names
23
 
    assert_equal(
24
 
      %w( id title author_name author_email_address bonus_time written_on last_read content approved replies_count parent_id parent_title type ).sort,
25
 
      @first.attribute_names
26
 
    )
27
 
  end
28
 
 
29
 
  def test_columns
30
 
    assert_equal 13, Topic.columns.length
31
 
  end
32
 
 
33
 
  def test_columns_are_returned_in_the_order_they_were_declared
34
 
    column_names = Topic.columns.map { |column| column.name }
35
 
    assert_equal %w(id title author_name author_email_address written_on bonus_time last_read content approved replies_count parent_id parent_title type), column_names
36
 
  end
37
 
 
38
 
  def test_content_columns
39
 
    content_columns        = Topic.content_columns
40
 
    content_column_names   = content_columns.map {|column| column.name}
41
 
    assert_equal 9, content_columns.length
42
 
    assert_equal %w(title author_name author_email_address written_on bonus_time last_read content approved parent_title).sort, content_column_names.sort
43
 
  end
44
 
 
45
 
  def test_column_string_type_and_limit
46
 
    assert_equal :string, @first.column_for_attribute("title").type
47
 
    assert_equal 255, @first.column_for_attribute("title").limit
48
 
  end
49
 
 
50
 
  def test_column_null_not_null
51
 
    subscriber = Subscriber.find(:first)
52
 
    assert subscriber.column_for_attribute("name").null
53
 
    assert !subscriber.column_for_attribute("nick").null
54
 
  end
55
 
 
56
 
  def test_human_name_for_column
57
 
    assert_equal "Author name", @first.column_for_attribute("author_name").human_name
58
 
  end
59
 
 
60
 
  def test_integer_columns
61
 
    assert_equal :integer, @first.column_for_attribute("id").type
62
 
  end
63
 
 
64
 
  def test_reflection_klass_for_nested_class_name
65
 
    reflection = ActiveRecord::Reflection::MacroReflection.new(nil, nil, { :class_name => 'MyApplication::Business::Company' }, nil)
66
 
    assert_nothing_raised do
67
 
      assert_equal MyApplication::Business::Company, reflection.klass
68
 
    end
69
 
  end
70
 
 
71
 
  def test_aggregation_reflection
72
 
    reflection_for_address = ActiveRecord::Reflection::AggregateReflection.new(
73
 
      :composed_of, :address, { :mapping => [ %w(address_street street), %w(address_city city), %w(address_country country) ] }, Customer
74
 
    )
75
 
 
76
 
    reflection_for_balance = ActiveRecord::Reflection::AggregateReflection.new(
77
 
      :composed_of, :balance, { :class_name => "Money", :mapping => %w(balance amount) }, Customer
78
 
    )
79
 
 
80
 
    reflection_for_gps_location = ActiveRecord::Reflection::AggregateReflection.new(
81
 
      :composed_of, :gps_location, { }, Customer
82
 
    )
83
 
 
84
 
    assert Customer.reflect_on_all_aggregations.include?(reflection_for_gps_location)
85
 
    assert Customer.reflect_on_all_aggregations.include?(reflection_for_balance)
86
 
    assert Customer.reflect_on_all_aggregations.include?(reflection_for_address)
87
 
 
88
 
    assert_equal reflection_for_address, Customer.reflect_on_aggregation(:address)
89
 
 
90
 
    assert_equal Address, Customer.reflect_on_aggregation(:address).klass
91
 
 
92
 
    assert_equal Money, Customer.reflect_on_aggregation(:balance).klass
93
 
  end
94
 
 
95
 
  def test_reflect_on_all_autosave_associations
96
 
    expected = Pirate.reflect_on_all_associations.select { |r| r.options[:autosave] }
97
 
    received = Pirate.reflect_on_all_autosave_associations
98
 
 
99
 
    assert !received.empty?
100
 
    assert_not_equal Pirate.reflect_on_all_associations.length, received.length
101
 
    assert_equal expected, received
102
 
  end
103
 
 
104
 
  def test_has_many_reflection
105
 
    reflection_for_clients = ActiveRecord::Reflection::AssociationReflection.new(:has_many, :clients, { :order => "id", :dependent => :destroy }, Firm)
106
 
 
107
 
    assert_equal reflection_for_clients, Firm.reflect_on_association(:clients)
108
 
 
109
 
    assert_equal Client, Firm.reflect_on_association(:clients).klass
110
 
    assert_equal 'companies', Firm.reflect_on_association(:clients).table_name
111
 
 
112
 
    assert_equal Client, Firm.reflect_on_association(:clients_of_firm).klass
113
 
    assert_equal 'companies', Firm.reflect_on_association(:clients_of_firm).table_name
114
 
  end
115
 
 
116
 
  def test_has_one_reflection
117
 
    reflection_for_account = ActiveRecord::Reflection::AssociationReflection.new(:has_one, :account, { :foreign_key => "firm_id", :dependent => :destroy }, Firm)
118
 
    assert_equal reflection_for_account, Firm.reflect_on_association(:account)
119
 
 
120
 
    assert_equal Account, Firm.reflect_on_association(:account).klass
121
 
    assert_equal 'accounts', Firm.reflect_on_association(:account).table_name
122
 
  end
123
 
 
124
 
  def test_belongs_to_inferred_foreign_key_from_assoc_name
125
 
    Company.belongs_to :foo
126
 
    assert_equal "foo_id", Company.reflect_on_association(:foo).primary_key_name
127
 
    Company.belongs_to :bar, :class_name => "Xyzzy"
128
 
    assert_equal "bar_id", Company.reflect_on_association(:bar).primary_key_name
129
 
    Company.belongs_to :baz, :class_name => "Xyzzy", :foreign_key => "xyzzy_id"
130
 
    assert_equal "xyzzy_id", Company.reflect_on_association(:baz).primary_key_name
131
 
  end
132
 
 
133
 
  def test_association_reflection_in_modules
134
 
    assert_reflection MyApplication::Business::Firm,
135
 
      :clients_of_firm,
136
 
      :klass      => MyApplication::Business::Client,
137
 
      :class_name => 'Client',
138
 
      :table_name => 'companies'
139
 
 
140
 
    assert_reflection MyApplication::Billing::Account,
141
 
      :firm,
142
 
      :klass      => MyApplication::Business::Firm,
143
 
      :class_name => 'MyApplication::Business::Firm',
144
 
      :table_name => 'companies'
145
 
 
146
 
    assert_reflection MyApplication::Billing::Account,
147
 
      :qualified_billing_firm,
148
 
      :klass      => MyApplication::Billing::Firm,
149
 
      :class_name => 'MyApplication::Billing::Firm',
150
 
      :table_name => 'companies'
151
 
 
152
 
    assert_reflection MyApplication::Billing::Account,
153
 
      :unqualified_billing_firm,
154
 
      :klass      => MyApplication::Billing::Firm,
155
 
      :class_name => 'Firm',
156
 
      :table_name => 'companies'
157
 
 
158
 
    assert_reflection MyApplication::Billing::Account,
159
 
      :nested_qualified_billing_firm,
160
 
      :klass      => MyApplication::Billing::Nested::Firm,
161
 
      :class_name => 'MyApplication::Billing::Nested::Firm',
162
 
      :table_name => 'companies'
163
 
 
164
 
    assert_reflection MyApplication::Billing::Account,
165
 
      :nested_unqualified_billing_firm,
166
 
      :klass      => MyApplication::Billing::Nested::Firm,
167
 
      :class_name => 'Nested::Firm',
168
 
      :table_name => 'companies'
169
 
  end
170
 
 
171
 
  def test_reflection_of_all_associations
172
 
    # FIXME these assertions bust a lot
173
 
    assert_equal 36, Firm.reflect_on_all_associations.size
174
 
    assert_equal 26, Firm.reflect_on_all_associations(:has_many).size
175
 
    assert_equal 10, Firm.reflect_on_all_associations(:has_one).size
176
 
    assert_equal 0, Firm.reflect_on_all_associations(:belongs_to).size
177
 
  end
178
 
 
179
 
  def test_reflection_should_not_raise_error_when_compared_to_other_object
180
 
    assert_nothing_raised { Firm.reflections[:clients] == Object.new }
181
 
  end
182
 
 
183
 
  def test_has_many_through_reflection
184
 
    assert_kind_of ActiveRecord::Reflection::ThroughReflection, Subscriber.reflect_on_association(:books)
185
 
  end
186
 
 
187
 
  private
188
 
    def assert_reflection(klass, association, options)
189
 
      assert reflection = klass.reflect_on_association(association)
190
 
      options.each do |method, value|
191
 
        assert_equal(value, reflection.send(method))
192
 
      end
193
 
    end
194
 
end