]> git.openstreetmap.org Git - rails.git/blob - test/test_helper.rb
04837f3903755f1d9ac015b4861bfe4a094a8d9a
[rails.git] / test / test_helper.rb
1 require "coveralls"
2 Coveralls.wear!("rails")
3
4 # Override the simplecov output message, since it is mostly unwanted noise
5 module SimpleCov
6   module Formatter
7     class HTMLFormatter
8       def output_message(_result); end
9     end
10   end
11 end
12
13 # Output both the local simplecov html and the coveralls report
14 SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter.new(
15   [SimpleCov::Formatter::HTMLFormatter,
16    Coveralls::SimpleCov::Formatter]
17 )
18
19 require "securerandom"
20 require "digest/sha1"
21
22 ENV["RAILS_ENV"] = "test"
23 require_relative "../config/environment"
24 require "rails/test_help"
25 require "webmock/minitest"
26
27 WebMock.disable_net_connect!(:allow_localhost => true)
28
29 module ActiveSupport
30   class TestCase
31     include FactoryBot::Syntax::Methods
32     include ActiveJob::TestHelper
33
34     # Run tests in parallel with specified workers
35     parallelize(:workers => :number_of_processors)
36
37     ##
38     # takes a block which is executed in the context of a different
39     # ActionController instance. this is used so that code can call methods
40     # on the node controller whilst testing the old_node controller.
41     def with_controller(new_controller)
42       controller_save = @controller
43       begin
44         @controller = new_controller
45         yield
46       ensure
47         @controller = controller_save
48       end
49     end
50
51     ##
52     # execute a block with missing translation exceptions suppressed
53     def without_i18n_exceptions
54       exception_handler = I18n.exception_handler
55       begin
56         I18n.exception_handler = nil
57         yield
58       ensure
59         I18n.exception_handler = exception_handler
60       end
61     end
62
63     ##
64     # work round minitest insanity that causes it to tell you
65     # to use assert_nil to test for nil, which is fine if you're
66     # comparing to a nil constant but not if you're comparing
67     # an expression that might be nil sometimes
68     def assert_equal_allowing_nil(exp, act, msg = nil)
69       if exp.nil?
70         assert_nil act, msg
71       else
72         assert_equal exp, act, msg
73       end
74     end
75
76     ##
77     # for some reason assert_equal a, b fails when the relations are
78     # actually equal, so this method manually checks the fields...
79     def assert_relations_are_equal(a, b)
80       assert_not_nil a, "first relation is not allowed to be nil"
81       assert_not_nil b, "second relation #{a.id} is not allowed to be nil"
82       assert_equal a.id, b.id, "relation IDs"
83       assert_equal a.changeset_id, b.changeset_id, "changeset ID on relation #{a.id}"
84       assert_equal a.visible, b.visible, "visible on relation #{a.id}, #{a.visible.inspect} != #{b.visible.inspect}"
85       assert_equal a.version, b.version, "version on relation #{a.id}"
86       assert_equal a.tags, b.tags, "tags on relation #{a.id}"
87       assert_equal a.members, b.members, "member references on relation #{a.id}"
88     end
89
90     ##
91     # for some reason assert_equal a, b fails when the ways are actually
92     # equal, so this method manually checks the fields...
93     def assert_ways_are_equal(a, b)
94       assert_not_nil a, "first way is not allowed to be nil"
95       assert_not_nil b, "second way #{a.id} is not allowed to be nil"
96       assert_equal a.id, b.id, "way IDs"
97       assert_equal a.changeset_id, b.changeset_id, "changeset ID on way #{a.id}"
98       assert_equal a.visible, b.visible, "visible on way #{a.id}, #{a.visible.inspect} != #{b.visible.inspect}"
99       assert_equal a.version, b.version, "version on way #{a.id}"
100       assert_equal a.tags, b.tags, "tags on way #{a.id}"
101       assert_equal a.nds, b.nds, "node references on way #{a.id}"
102     end
103
104     ##
105     # for some reason a==b is false, but there doesn't seem to be any
106     # difference between the nodes, so i'm checking all the attributes
107     # manually and blaming it on ActiveRecord
108     def assert_nodes_are_equal(a, b)
109       assert_equal a.id, b.id, "node IDs"
110       assert_equal a.latitude, b.latitude, "latitude on node #{a.id}"
111       assert_equal a.longitude, b.longitude, "longitude on node #{a.id}"
112       assert_equal a.changeset_id, b.changeset_id, "changeset ID on node #{a.id}"
113       assert_equal a.visible, b.visible, "visible on node #{a.id}"
114       assert_equal a.version, b.version, "version on node #{a.id}"
115       assert_equal a.tags, b.tags, "tags on node #{a.id}"
116     end
117
118     ##
119     # set request headers for HTTP basic authentication
120     def basic_authorization(user, pass)
121       @request.env["HTTP_AUTHORIZATION"] = format("Basic %{auth}", :auth => Base64.encode64("#{user}:#{pass}"))
122     end
123
124     ##
125     # return request header for HTTP Basic Authorization
126     def basic_authorization_header(user, pass)
127       { "Authorization" => format("Basic %{auth}", :auth => Base64.encode64("#{user}:#{pass}")) }
128     end
129
130     ##
131     # make an OAuth signed request
132     def signed_request(method, uri, options = {})
133       uri = URI.parse(uri)
134       uri.scheme ||= "http"
135       uri.host ||= "www.example.com"
136
137       oauth = options.delete(:oauth)
138       params = options.fetch(:params, {}).transform_keys(&:to_s)
139
140       oauth[:consumer] ||= oauth[:token].client_application
141
142       helper = OAuth::Client::Helper.new(nil, oauth)
143
144       request = OAuth::RequestProxy.proxy(
145         "method" => method.to_s.upcase,
146         "uri" => uri,
147         "parameters" => params.merge(helper.oauth_parameters)
148       )
149
150       request.sign!(oauth)
151
152       method(method).call(request.signed_uri, options)
153     end
154
155     ##
156     # make an OAuth signed GET request
157     def signed_get(uri, options = {})
158       signed_request(:get, uri, options)
159     end
160
161     ##
162     # make an OAuth signed POST request
163     def signed_post(uri, options = {})
164       signed_request(:post, uri, options)
165     end
166
167     ##
168     # set request header for HTTP Accept
169     def http_accept_format(format)
170       @request.env["HTTP_ACCEPT"] = format
171     end
172
173     ##
174     # set request readers to ask for a particular error format
175     def error_format(format)
176       @request.env["HTTP_X_ERROR_FORMAT"] = format
177     end
178
179     def error_format_header(f)
180       { "X-Error-Format" => f }
181     end
182
183     ##
184     # Used to check that the error header and the forbidden responses are given
185     # when the owner of the changset has their data not marked as public
186     def assert_require_public_data(msg = "Shouldn't be able to use API when the user's data is not public")
187       assert_response :forbidden, msg
188       assert_equal @response.headers["Error"], "You must make your edits public to upload new data", "Wrong error message"
189     end
190
191     ##
192     # Not sure this is the best response we could give
193     def assert_inactive_user(msg = "an inactive user shouldn't be able to access the API")
194       assert_response :unauthorized, msg
195       # assert_equal @response.headers['Error'], ""
196     end
197
198     ##
199     # Check for missing translations in an HTML response
200     def assert_no_missing_translations(msg = "")
201       assert_select "span[class=translation_missing]", false, "Missing translation #{msg}"
202     end
203
204     ##
205     # execute a block with a given set of HTTP responses stubbed
206     def with_http_stubs(stubs_file)
207       stubs = YAML.load_file(File.expand_path("../http/#{stubs_file}.yml", __FILE__))
208       stubs.each do |url, response|
209         stub_request(:get, Regexp.new(Regexp.quote(url))).to_return(:status => response["code"], :body => response["body"])
210       end
211
212       yield
213     end
214
215     def stub_gravatar_request(email, status = 200, body = nil)
216       hash = ::Digest::MD5.hexdigest(email.downcase)
217       url = "https://www.gravatar.com/avatar/#{hash}?d=404"
218       stub_request(:get, url).and_return(:status => status, :body => body)
219     end
220
221     def email_text_parts(message)
222       message.parts.each_with_object([]) do |part, text_parts|
223         if part.content_type.start_with?("text/")
224           text_parts.push(part)
225         elsif part.multipart?
226           text_parts.concat(email_text_parts(part))
227         end
228       end
229     end
230
231     def sign_in_as(user)
232       visit login_path
233       fill_in "username", :with => user.email
234       fill_in "password", :with => "test"
235       click_on "Login", :match => :first
236     end
237
238     def session_for(user)
239       post login_path, :params => { :username => user.display_name, :password => "test" }
240       follow_redirect!
241     end
242
243     def xml_for_node(node)
244       doc = OSM::API.new.get_xml_doc
245       doc.root << xml_node_for_node(node)
246       doc
247     end
248
249     def xml_node_for_node(node)
250       el = XML::Node.new "node"
251       el["id"] = node.id.to_s
252
253       OMHelper.add_metadata_to_xml_node(el, node, {}, {})
254
255       if node.visible?
256         el["lat"] = node.lat.to_s
257         el["lon"] = node.lon.to_s
258       end
259
260       OMHelper.add_tags_to_xml_node(el, node.node_tags)
261
262       el
263     end
264
265     def xml_for_way(way)
266       doc = OSM::API.new.get_xml_doc
267       doc.root << xml_node_for_way(way)
268       doc
269     end
270
271     def xml_node_for_way(way)
272       el = XML::Node.new "way"
273       el["id"] = way.id.to_s
274
275       OMHelper.add_metadata_to_xml_node(el, way, {}, {})
276
277       # make sure nodes are output in sequence_id order
278       ordered_nodes = []
279       way.way_nodes.each do |nd|
280         ordered_nodes[nd.sequence_id] = nd.node_id.to_s if nd.node&.visible?
281       end
282
283       ordered_nodes.each do |nd_id|
284         next unless nd_id && nd_id != "0"
285
286         node_el = XML::Node.new "nd"
287         node_el["ref"] = nd_id
288         el << node_el
289       end
290
291       OMHelper.add_tags_to_xml_node(el, way.way_tags)
292
293       el
294     end
295
296     def xml_for_relation(relation)
297       doc = OSM::API.new.get_xml_doc
298       doc.root << xml_node_for_relation(relation)
299       doc
300     end
301
302     def xml_node_for_relation(relation)
303       el = XML::Node.new "relation"
304       el["id"] = relation.id.to_s
305
306       OMHelper.add_metadata_to_xml_node(el, relation, {}, {})
307
308       relation.relation_members.each do |member|
309         member_el = XML::Node.new "member"
310         member_el["type"] = member.member_type.downcase
311         member_el["ref"] = member.member_id.to_s
312         member_el["role"] = member.member_role
313         el << member_el
314       end
315
316       OMHelper.add_tags_to_xml_node(el, relation.relation_tags)
317
318       el
319     end
320
321     class OMHelper
322       extend ObjectMetadata
323     end
324   end
325 end