Merge branch 'master' into 15531-logincluster-migrate
[arvados.git] / apps / workbench / test / test_helper.rb
1 # Copyright (C) The Arvados Authors. All rights reserved.
2 #
3 # SPDX-License-Identifier: AGPL-3.0
4
5 ENV["RAILS_ENV"] = "test" if (ENV["RAILS_ENV"] != "diagnostics" and ENV["RAILS_ENV"] != "performance")
6
7 unless ENV["NO_COVERAGE_TEST"]
8   begin
9     require 'simplecov'
10     require 'simplecov-rcov'
11     class SimpleCov::Formatter::MergedFormatter
12       def format(result)
13         SimpleCov::Formatter::HTMLFormatter.new.format(result)
14         SimpleCov::Formatter::RcovFormatter.new.format(result)
15       end
16     end
17     SimpleCov.formatter = SimpleCov::Formatter::MergedFormatter
18     SimpleCov.start do
19       add_filter '/test/'
20       add_filter 'initializers/secret_token'
21     end
22   rescue Exception => e
23     $stderr.puts "SimpleCov unavailable (#{e}). Proceeding without."
24   end
25 end
26
27 require File.expand_path('../../config/environment', __FILE__)
28 require 'rails/test_help'
29 require 'mocha/minitest'
30
31 class ActiveSupport::TestCase
32   # Setup all fixtures in test/fixtures/*.(yml|csv) for all tests in
33   # alphabetical order.
34   #
35   # Note: You'll currently still have to declare fixtures explicitly
36   # in integration tests -- they do not yet inherit this setting
37   fixtures :all
38   def use_token(token_name)
39     user_was = Thread.current[:user]
40     token_was = Thread.current[:arvados_api_token]
41     auth = api_fixture('api_client_authorizations')[token_name.to_s]
42     Thread.current[:arvados_api_token] = "v2/#{auth['uuid']}/#{auth['api_token']}"
43     if block_given?
44       begin
45         yield
46       ensure
47         Thread.current[:user] = user_was
48         Thread.current[:arvados_api_token] = token_was
49       end
50     end
51   end
52
53   teardown do
54     Thread.current[:arvados_api_token] = nil
55     Thread.current[:user] = nil
56     Thread.current[:reader_tokens] = nil
57     # Diagnostics suite doesn't run a server, so there's no cache to clear.
58     Rails.cache.clear unless (Rails.env == "diagnostics")
59     # Restore configuration settings changed during tests
60     self.class.reset_application_config
61   end
62
63   def self.reset_application_config
64     # Restore configuration settings changed during tests
65     ConfigLoader.copy_into_config $arvados_config, Rails.configuration
66     ConfigLoader.copy_into_config $remaining_config, Rails.configuration
67     Rails.configuration.Services.Controller.ExternalURL = URI("https://#{ENV['ARVADOS_API_HOST']}")
68     Rails.configuration.TLS.Insecure = true
69   end
70 end
71
72 module ApiFixtureLoader
73   def self.included(base)
74     base.extend(ClassMethods)
75   end
76
77   module ClassMethods
78     @@api_fixtures = {}
79     def api_fixture(name, *keys)
80       # Returns the data structure from the named API server test fixture.
81       @@api_fixtures[name] ||= \
82       begin
83         path = File.join(ApiServerForTests::ARV_API_SERVER_DIR,
84                          'test', 'fixtures', "#{name}.yml")
85         file = IO.read(path)
86         trim_index = file.index('# Test Helper trims the rest of the file')
87         file = file[0, trim_index] if trim_index
88         YAML.load(file).each do |name, ob|
89           ob.reject! { |k, v| k.start_with?('secret_') }
90         end
91       end
92       keys.inject(@@api_fixtures[name]) { |hash, key| hash[key] }.deep_dup
93     end
94   end
95
96   def api_fixture(name, *keys)
97     self.class.api_fixture(name, *keys)
98   end
99
100   def api_token(name)
101     auth = api_fixture('api_client_authorizations')[name]
102     "v2/#{auth['uuid']}/#{auth['api_token']}"
103   end
104
105   def find_fixture(object_class, name)
106     object_class.find(api_fixture(object_class.to_s.pluralize.underscore,
107                                   name, "uuid"))
108   end
109 end
110
111 module ApiMockHelpers
112   def fake_api_response body, status_code, headers
113     resp = mock
114     resp.responds_like_instance_of HTTP::Message
115     resp.stubs(:headers).returns headers
116     resp.stubs(:content).returns body
117     resp.stubs(:status_code).returns status_code
118     resp
119   end
120
121   def stub_api_calls_with_body body, status_code=200, headers={}
122     stub_api_calls
123     resp = fake_api_response body, status_code, headers
124     stub_api_client.stubs(:post).returns resp
125   end
126
127   def stub_api_calls
128     @stubbed_client = ArvadosApiClient.new
129     @stubbed_client.instance_eval do
130       @api_client = HTTPClient.new
131     end
132     ArvadosApiClient.stubs(:new_or_current).returns(@stubbed_client)
133   end
134
135   def stub_api_calls_with_invalid_json
136     stub_api_calls_with_body ']"omg,bogus"['
137   end
138
139   # Return the HTTPClient mock used by the ArvadosApiClient mock. You
140   # must have called stub_api_calls first.
141   def stub_api_client
142     @stubbed_client.instance_eval do
143       @api_client
144     end
145   end
146 end
147
148 class ActiveSupport::TestCase
149   include ApiMockHelpers
150 end
151
152 class ActiveSupport::TestCase
153   include ApiFixtureLoader
154   def session_for api_client_auth_name
155     auth = api_fixture('api_client_authorizations')[api_client_auth_name.to_s]
156     {
157       arvados_api_token: "v2/#{auth['uuid']}/#{auth['api_token']}"
158     }
159   end
160   def json_response
161     Oj.load(@response.body)
162   end
163 end
164
165 class ApiServerForTests
166   PYTHON_TESTS_DIR = File.expand_path('../../../../sdk/python/tests', __FILE__)
167   ARV_API_SERVER_DIR = File.expand_path('../../../../services/api', __FILE__)
168   SERVER_PID_PATH = File.expand_path('tmp/pids/test-server.pid', ARV_API_SERVER_DIR)
169   WEBSOCKET_PID_PATH = File.expand_path('tmp/pids/test-server.pid', ARV_API_SERVER_DIR)
170   @main_process_pid = $$
171   @@server_is_running = false
172
173   def check_output *args
174     output = nil
175     Bundler.with_clean_env do
176       output = IO.popen *args do |io|
177         io.read
178       end
179       if not $?.success?
180         raise RuntimeError, "Command failed (#{$?}): #{args.inspect}"
181       end
182     end
183     output
184   end
185
186   def run_test_server
187     Dir.chdir PYTHON_TESTS_DIR do
188       check_output %w(python ./run_test_server.py start_keep)
189     end
190   end
191
192   def stop_test_server
193     Dir.chdir PYTHON_TESTS_DIR do
194       check_output %w(python ./run_test_server.py stop_keep)
195     end
196     @@server_is_running = false
197   end
198
199   def run args=[]
200     return if @@server_is_running
201
202     # Stop server left over from interrupted previous run
203     stop_test_server
204
205     ::MiniTest.after_run do
206       stop_test_server
207     end
208
209     run_test_server
210     ActiveSupport::TestCase.reset_application_config
211
212     @@server_is_running = true
213   end
214
215   def run_rake_task task_name, arg_string
216     Dir.chdir ARV_API_SERVER_DIR do
217       check_output ['bundle', 'exec', 'rake', "#{task_name}[#{arg_string}]"]
218     end
219   end
220 end
221
222 class ActionController::TestCase
223   setup do
224     @test_counter = 0
225   end
226
227   def check_counter action
228     @test_counter += 1
229     if @test_counter == 2
230       assert_equal 1, 2, "Multiple actions in controller test"
231     end
232   end
233
234   [:get, :post, :put, :patch, :delete].each do |method|
235     define_method method do |action, *args|
236       check_counter action
237       super action, *args
238     end
239   end
240 end
241
242 # Test classes can call reset_api_fixtures(when_to_reset,flag) to
243 # override the default. Example:
244 #
245 # class MySuite < ActionDispatch::IntegrationTest
246 #   reset_api_fixtures :after_each_test, false
247 #   reset_api_fixtures :after_suite, true
248 #   ...
249 # end
250 #
251 # The default behavior is reset_api_fixtures(:after_each_test,true).
252 #
253 class ActiveSupport::TestCase
254
255   def self.inherited subclass
256     subclass.class_eval do
257       class << self
258         attr_accessor :want_reset_api_fixtures
259       end
260       @want_reset_api_fixtures = {
261         after_each_test: true,
262         after_suite: false,
263         before_suite: false,
264       }
265     end
266     super
267   end
268   # Existing subclasses of ActiveSupport::TestCase (ones that already
269   # existed before we set up the self.inherited hook above) will not
270   # get their own instance variable. They're not real test cases
271   # anyway, so we give them a "don't reset anywhere" stub.
272   def self.want_reset_api_fixtures
273     {}
274   end
275
276   def self.reset_api_fixtures where, t=true
277     if not want_reset_api_fixtures.has_key? where
278       raise ArgumentError, "There is no #{where.inspect} hook"
279     end
280     self.want_reset_api_fixtures[where] = t
281   end
282
283   def self.run *args
284     reset_api_fixtures_now if want_reset_api_fixtures[:before_suite]
285     result = super
286     reset_api_fixtures_now if want_reset_api_fixtures[:after_suite]
287     result
288   end
289
290   def after_teardown
291     if self.class.want_reset_api_fixtures[:after_each_test] and
292         (!defined?(@want_reset_api_fixtures) or @want_reset_api_fixtures != false)
293       self.class.reset_api_fixtures_now
294     end
295     super
296   end
297
298   def reset_api_fixtures_after_test t=true
299     @want_reset_api_fixtures = t
300   end
301
302   protected
303   def self.reset_api_fixtures_now
304     # Never try to reset fixtures when we're just using test
305     # infrastructure to run performance/diagnostics suites.
306     return unless Rails.env == 'test'
307
308     auth = api_fixture('api_client_authorizations')['admin_trustedclient']
309     Thread.current[:arvados_api_token] = "v2/#{auth['uuid']}/#{auth['api_token']}"
310     ArvadosApiClient.new.api(nil, '../../database/reset', {})
311     Thread.current[:arvados_api_token] = nil
312   end
313 end
314
315 # If it quacks like a duck, it must be a HTTP request object.
316 class RequestDuck
317   def self.host
318     "localhost"
319   end
320
321   def self.port
322     8080
323   end
324
325   def self.protocol
326     "http"
327   end
328 end
329
330 # Example:
331 #
332 # apps/workbench$ RAILS_ENV=test bundle exec irb -Ilib:test
333 # > load 'test/test_helper.rb'
334 # > singletest 'integration/collection_upload_test.rb', 'Upload two empty files'
335 #
336 def singletest test_class_file, test_name
337   load File.join('test', test_class_file)
338   Minitest.run ['-v', '-n', "test_#{test_name.gsub ' ', '_'}"]
339   Object.send(:remove_const,
340               test_class_file.gsub(/.*\/|\.rb$/, '').camelize.to_sym)
341   ::Minitest::Runnable.runnables.reject! { true }
342 end
343
344 if ENV["RAILS_ENV"].eql? 'test'
345   ApiServerForTests.new.run
346   ApiServerForTests.new.run ["--websockets"]
347 end
348
349 # Reset fixtures now (i.e., before any tests run).
350 ActiveSupport::TestCase.reset_api_fixtures_now
351
352 module Minitest
353   class Test
354     def capture_exceptions *args
355       begin
356         n = 0
357         begin
358           yield
359         rescue *PASSTHROUGH_EXCEPTIONS
360           raise
361         rescue Exception => e
362           n += 1
363           raise if n > 2 || e.is_a?(Skip)
364           STDERR.puts "Test failed, retrying (##{n})"
365           retry
366         end
367       rescue *PASSTHROUGH_EXCEPTIONS
368         raise
369       rescue Assertion => e
370         self.failures << e
371       rescue Exception => e
372         self.failures << UnexpectedError.new(e)
373       end
374     end
375   end
376 end