Merge remote-tracking branch 'upstream/pull/2896'
[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     # return request header for HTTP Basic Authorization
120     def basic_authorization_header(user, pass)
121       { "Authorization" => format("Basic %<auth>s", :auth => Base64.encode64("#{user}:#{pass}")) }
122     end
123
124     ##
125     # make an OAuth signed request
126     def signed_request(method, uri, options = {})
127       uri = URI.parse(uri)
128       uri.scheme ||= "http"
129       uri.host ||= "www.example.com"
130
131       oauth = options.delete(:oauth)
132       params = options.fetch(:params, {}).transform_keys(&:to_s)
133
134       oauth[:consumer] ||= oauth[:token].client_application
135
136       helper = OAuth::Client::Helper.new(nil, oauth)
137
138       request = OAuth::RequestProxy.proxy(
139         "method" => method.to_s.upcase,
140         "uri" => uri,
141         "parameters" => params.merge(helper.oauth_parameters)
142       )
143
144       request.sign!(oauth)
145
146       method(method).call(request.signed_uri, options)
147     end
148
149     ##
150     # make an OAuth signed GET request
151     def signed_get(uri, options = {})
152       signed_request(:get, uri, options)
153     end
154
155     ##
156     # make an OAuth signed POST request
157     def signed_post(uri, options = {})
158       signed_request(:post, uri, options)
159     end
160
161     ##
162     # return request header for HTTP Accept
163     def accept_format_header(format)
164       { "Accept" => format }
165     end
166
167     ##
168     # return request header to ask for a particular error format
169     def error_format_header(f)
170       { "X-Error-Format" => f }
171     end
172
173     ##
174     # Used to check that the error header and the forbidden responses are given
175     # when the owner of the changset has their data not marked as public
176     def assert_require_public_data(msg = "Shouldn't be able to use API when the user's data is not public")
177       assert_response :forbidden, msg
178       assert_equal("You must make your edits public to upload new data", @response.headers["Error"], "Wrong error message")
179     end
180
181     ##
182     # Not sure this is the best response we could give
183     def assert_inactive_user(msg = "an inactive user shouldn't be able to access the API")
184       assert_response :unauthorized, msg
185       # assert_equal @response.headers['Error'], ""
186     end
187
188     ##
189     # Check for missing translations in an HTML response
190     def assert_no_missing_translations(msg = "")
191       assert_select "span[class=translation_missing]", false, "Missing translation #{msg}"
192     end
193
194     ##
195     # execute a block with a given set of HTTP responses stubbed
196     def with_http_stubs(stubs_file)
197       stubs = YAML.load_file(File.expand_path("../http/#{stubs_file}.yml", __FILE__))
198       stubs.each do |url, response|
199         stub_request(:get, Regexp.new(Regexp.quote(url))).to_return(:status => response["code"], :body => response["body"])
200       end
201
202       yield
203     end
204
205     def stub_gravatar_request(email, status = 200, body = nil)
206       hash = ::Digest::MD5.hexdigest(email.downcase)
207       url = "https://www.gravatar.com/avatar/#{hash}?d=404"
208       stub_request(:get, url).and_return(:status => status, :body => body)
209     end
210
211     def email_text_parts(message)
212       message.parts.each_with_object([]) do |part, text_parts|
213         if part.content_type.start_with?("text/")
214           text_parts.push(part)
215         elsif part.multipart?
216           text_parts.concat(email_text_parts(part))
217         end
218       end
219     end
220
221     def sign_in_as(user)
222       visit login_path
223       fill_in "username", :with => user.email
224       fill_in "password", :with => "test"
225       click_on "Login", :match => :first
226     end
227
228     def session_for(user)
229       post login_path, :params => { :username => user.display_name, :password => "test" }
230       follow_redirect!
231     end
232
233     def xml_for_node(node)
234       doc = OSM::API.new.get_xml_doc
235       doc.root << xml_node_for_node(node)
236       doc
237     end
238
239     def xml_node_for_node(node)
240       el = XML::Node.new "node"
241       el["id"] = node.id.to_s
242
243       OMHelper.add_metadata_to_xml_node(el, node, {}, {})
244
245       if node.visible?
246         el["lat"] = node.lat.to_s
247         el["lon"] = node.lon.to_s
248       end
249
250       OMHelper.add_tags_to_xml_node(el, node.node_tags)
251
252       el
253     end
254
255     def xml_for_way(way)
256       doc = OSM::API.new.get_xml_doc
257       doc.root << xml_node_for_way(way)
258       doc
259     end
260
261     def xml_node_for_way(way)
262       el = XML::Node.new "way"
263       el["id"] = way.id.to_s
264
265       OMHelper.add_metadata_to_xml_node(el, way, {}, {})
266
267       # make sure nodes are output in sequence_id order
268       ordered_nodes = []
269       way.way_nodes.each do |nd|
270         ordered_nodes[nd.sequence_id] = nd.node_id.to_s if nd.node&.visible?
271       end
272
273       ordered_nodes.each do |nd_id|
274         next unless nd_id && nd_id != "0"
275
276         node_el = XML::Node.new "nd"
277         node_el["ref"] = nd_id
278         el << node_el
279       end
280
281       OMHelper.add_tags_to_xml_node(el, way.way_tags)
282
283       el
284     end
285
286     def xml_for_relation(relation)
287       doc = OSM::API.new.get_xml_doc
288       doc.root << xml_node_for_relation(relation)
289       doc
290     end
291
292     def xml_node_for_relation(relation)
293       el = XML::Node.new "relation"
294       el["id"] = relation.id.to_s
295
296       OMHelper.add_metadata_to_xml_node(el, relation, {}, {})
297
298       relation.relation_members.each do |member|
299         member_el = XML::Node.new "member"
300         member_el["type"] = member.member_type.downcase
301         member_el["ref"] = member.member_id.to_s
302         member_el["role"] = member.member_role
303         el << member_el
304       end
305
306       OMHelper.add_tags_to_xml_node(el, relation.relation_tags)
307
308       el
309     end
310
311     class OMHelper
312       extend ObjectMetadata
313     end
314   end
315 end