Refactor remaining way model tests to use factories.
[rails.git] / test / models / way_test.rb
1 require "test_helper"
2
3 class WayTest < ActiveSupport::TestCase
4   api_fixtures
5
6   # Check that we have the correct number of currnet ways in the db
7   # This will need to updated whenever the current_ways.yml is updated
8   def test_db_count
9     assert_equal 7, Way.count
10   end
11
12   def test_bbox
13     node = create(:node)
14     visible_way = create(:way)
15     create(:way_node, :way => visible_way, :node => node)
16     invisible_way = create(:way, :deleted)
17     create(:way_node, :way => invisible_way, :node => node)
18     used_way = create(:way)
19     create(:way_node, :way => used_way, :node => node)
20     create(:relation_member, :member => used_way)
21
22     [visible_way, invisible_way, used_way].each do |way|
23       assert_equal node.bbox.min_lon, way.bbox.min_lon, "min_lon"
24       assert_equal node.bbox.min_lat, way.bbox.min_lat, "min_lat"
25       assert_equal node.bbox.max_lon, way.bbox.max_lon, "max_lon"
26       assert_equal node.bbox.max_lat, way.bbox.max_lat, "max_lat"
27     end
28   end
29
30   # Check that the preconditions fail when you are over the defined limit of
31   # the maximum number of nodes in each way.
32   def test_max_nodes_per_way_limit
33     node_a = create(:node)
34     node_b = create(:node)
35     node_c = create(:node)
36     way = create(:way_with_nodes, :nodes_count => 1)
37     # Take one of the current ways and add nodes to it until we are near the limit
38     assert way.valid?
39     # it already has 1 node
40     1.upto(MAX_NUMBER_OF_WAY_NODES / 2) do
41       way.add_nd_num(node_a.id)
42       way.add_nd_num(node_b.id)
43     end
44     way.save
45     # print way.nds.size
46     assert way.valid?
47     way.add_nd_num(node_c.id)
48     assert way.valid?
49   end
50
51   def test_from_xml_no_id
52     noid = "<osm><way version='12' changeset='23' /></osm>"
53     assert_nothing_raised(OSM::APIBadXMLError) do
54       Way.from_xml(noid, true)
55     end
56     message = assert_raise(OSM::APIBadXMLError) do
57       Way.from_xml(noid, false)
58     end
59     assert_match /ID is required when updating/, message.message
60   end
61
62   def test_from_xml_no_changeset_id
63     nocs = "<osm><way id='123' version='23' /></osm>"
64     message_create = assert_raise(OSM::APIBadXMLError) do
65       Way.from_xml(nocs, true)
66     end
67     assert_match /Changeset id is missing/, message_create.message
68     message_update = assert_raise(OSM::APIBadXMLError) do
69       Way.from_xml(nocs, false)
70     end
71     assert_match /Changeset id is missing/, message_update.message
72   end
73
74   def test_from_xml_no_version
75     no_version = "<osm><way id='123' changeset='23' /></osm>"
76     assert_nothing_raised(OSM::APIBadXMLError) do
77       Way.from_xml(no_version, true)
78     end
79     message_update = assert_raise(OSM::APIBadXMLError) do
80       Way.from_xml(no_version, false)
81     end
82     assert_match /Version is required when updating/, message_update.message
83   end
84
85   def test_from_xml_id_zero
86     id_list = ["", "0", "00", "0.0", "a"]
87     id_list.each do |id|
88       zero_id = "<osm><way id='#{id}' changeset='33' version='23' /></osm>"
89       assert_nothing_raised(OSM::APIBadUserInput) do
90         Way.from_xml(zero_id, true)
91       end
92       message_update = assert_raise(OSM::APIBadUserInput) do
93         Way.from_xml(zero_id, false)
94       end
95       assert_match /ID of way cannot be zero when updating/, message_update.message
96     end
97   end
98
99   def test_from_xml_no_text
100     no_text = ""
101     message_create = assert_raise(OSM::APIBadXMLError) do
102       Way.from_xml(no_text, true)
103     end
104     assert_match /Must specify a string with one or more characters/, message_create.message
105     message_update = assert_raise(OSM::APIBadXMLError) do
106       Way.from_xml(no_text, false)
107     end
108     assert_match /Must specify a string with one or more characters/, message_update.message
109   end
110
111   def test_from_xml_no_k_v
112     nokv = "<osm><way id='23' changeset='23' version='23'><tag /></way></osm>"
113     message_create = assert_raise(OSM::APIBadXMLError) do
114       Way.from_xml(nokv, true)
115     end
116     assert_match /tag is missing key/, message_create.message
117     message_update = assert_raise(OSM::APIBadXMLError) do
118       Way.from_xml(nokv, false)
119     end
120     assert_match /tag is missing key/, message_update.message
121   end
122
123   def test_from_xml_no_v
124     no_v = "<osm><way id='23' changeset='23' version='23'><tag k='key' /></way></osm>"
125     message_create = assert_raise(OSM::APIBadXMLError) do
126       Way.from_xml(no_v, true)
127     end
128     assert_match /tag is missing value/, message_create.message
129     message_update = assert_raise(OSM::APIBadXMLError) do
130       Way.from_xml(no_v, false)
131     end
132     assert_match /tag is missing value/, message_update.message
133   end
134
135   def test_from_xml_duplicate_k
136     dupk = "<osm><way id='23' changeset='23' version='23'><tag k='dup' v='test' /><tag k='dup' v='tester' /></way></osm>"
137     message_create = assert_raise(OSM::APIDuplicateTagsError) do
138       Way.from_xml(dupk, true)
139     end
140     assert_equal "Element way/ has duplicate tags with key dup", message_create.message
141     message_update = assert_raise(OSM::APIDuplicateTagsError) do
142       Way.from_xml(dupk, false)
143     end
144     assert_equal "Element way/23 has duplicate tags with key dup", message_update.message
145   end
146
147   def test_way_nodes
148     way = create(:way)
149     node1 = create(:way_node, :way => way, :sequence_id => 1).node
150     node2 = create(:way_node, :way => way, :sequence_id => 2).node
151     node3 = create(:way_node, :way => way, :sequence_id => 3).node
152
153     nodes = Way.find(way.id).way_nodes
154     assert_equal 3, nodes.count
155     assert_equal node1.id, nodes[0].node_id
156     assert_equal node2.id, nodes[1].node_id
157     assert_equal node3.id, nodes[2].node_id
158   end
159
160   def test_nodes
161     way = create(:way)
162     node1 = create(:way_node, :way => way, :sequence_id => 1).node
163     node2 = create(:way_node, :way => way, :sequence_id => 2).node
164     node3 = create(:way_node, :way => way, :sequence_id => 3).node
165
166     nodes = Way.find(way.id).nodes
167     assert_equal 3, nodes.count
168     assert_equal node1.id, nodes[0].id
169     assert_equal node2.id, nodes[1].id
170     assert_equal node3.id, nodes[2].id
171   end
172
173   def test_nds
174     way = create(:way)
175     node1 = create(:way_node, :way => way, :sequence_id => 1).node
176     node2 = create(:way_node, :way => way, :sequence_id => 2).node
177     node3 = create(:way_node, :way => way, :sequence_id => 3).node
178
179     nodes = Way.find(way.id).nds
180     assert_equal 3, nodes.count
181     assert_equal node1.id, nodes[0]
182     assert_equal node2.id, nodes[1]
183     assert_equal node3.id, nodes[2]
184   end
185
186   def test_way_tags
187     way = create(:way)
188     taglist = create_list(:way_tag, 2, :way => way)
189     tags = Way.find(way.id).way_tags.order(:k)
190     assert_equal taglist.count, tags.count
191     taglist.sort_by!(&:k).each_index do |i|
192       assert_equal taglist[i].k, tags[i].k
193       assert_equal taglist[i].v, tags[i].v
194     end
195   end
196
197   def test_tags
198     way = create(:way)
199     taglist = create_list(:way_tag, 2, :way => way)
200     tags = Way.find(way.id).tags
201     assert_equal taglist.count, tags.count
202     taglist.each do |tag|
203       assert_equal tag.v, tags[tag.k]
204     end
205   end
206
207   def test_containing_relation_members
208     way = create(:way)
209     relation = create(:relation)
210     create(:relation_member, :relation => relation, :member => way)
211
212     crm = Way.find(way.id).containing_relation_members.order(:relation_id)
213     #    assert_equal 1, crm.size
214     assert_equal relation.id, crm.first.relation_id
215     assert_equal "Way", crm.first.member_type
216     assert_equal way.id, crm.first.member_id
217     assert_equal relation.id, crm.first.relation.id
218   end
219
220   def test_containing_relations
221     way = create(:way)
222     relation = create(:relation)
223     create(:relation_member, :relation => relation, :member => way)
224
225     cr = Way.find(way.id).containing_relations.order(:id)
226     assert_equal 1, cr.size
227     assert_equal relation.id, cr.first.id
228   end
229 end