testcentricity_web 4.3.0 → 4.4.0

Sign up to get free protection for your applications and to get access to all the features.
Files changed (33) hide show
  1. checksums.yaml +4 -4
  2. data/CHANGELOG.md +46 -11
  3. data/LICENSE.md +1 -1
  4. data/README.md +1931 -801
  5. data/lib/devices/devices.yml +144 -216
  6. data/lib/testcentricity_web/browser_helper.rb +33 -4
  7. data/lib/testcentricity_web/data_objects/environment.rb +96 -15
  8. data/lib/testcentricity_web/exception_queue_helper.rb +5 -6
  9. data/lib/testcentricity_web/version.rb +1 -1
  10. data/lib/testcentricity_web/web_core/page_object.rb +53 -49
  11. data/lib/testcentricity_web/web_core/page_objects_helper.rb +20 -11
  12. data/lib/testcentricity_web/web_core/page_section.rb +31 -34
  13. data/lib/testcentricity_web/web_core/webdriver_helper.rb +416 -288
  14. data/lib/testcentricity_web/web_elements/audio.rb +6 -4
  15. data/lib/testcentricity_web/web_elements/button.rb +7 -4
  16. data/lib/testcentricity_web/web_elements/checkbox.rb +149 -147
  17. data/lib/testcentricity_web/web_elements/file_field.rb +38 -36
  18. data/lib/testcentricity_web/web_elements/image.rb +75 -70
  19. data/lib/testcentricity_web/web_elements/label.rb +6 -4
  20. data/lib/testcentricity_web/web_elements/link.rb +15 -13
  21. data/lib/testcentricity_web/web_elements/list.rb +171 -169
  22. data/lib/testcentricity_web/web_elements/media.rb +384 -379
  23. data/lib/testcentricity_web/web_elements/radio.rb +135 -133
  24. data/lib/testcentricity_web/web_elements/range.rb +16 -29
  25. data/lib/testcentricity_web/web_elements/select_list.rb +247 -245
  26. data/lib/testcentricity_web/web_elements/table.rb +575 -573
  27. data/lib/testcentricity_web/web_elements/textfield.rb +143 -139
  28. data/lib/testcentricity_web/web_elements/ui_element.rb +1171 -0
  29. data/lib/testcentricity_web/web_elements/video.rb +39 -37
  30. data/lib/testcentricity_web/world_extensions.rb +37 -4
  31. data/lib/testcentricity_web.rb +4 -23
  32. metadata +27 -79
  33. data/lib/testcentricity_web/web_elements/ui_elements_helper.rb +0 -1148
@@ -1,7 +1,6 @@
1
1
  require 'selenium-webdriver'
2
2
  require 'os'
3
3
  require 'browserstack/local'
4
- require 'webdrivers'
5
4
  require 'fileutils'
6
5
 
7
6
 
@@ -10,43 +9,47 @@ module TestCentricity
10
9
  include Capybara::DSL
11
10
 
12
11
  attr_accessor :bs_local
12
+ attr_accessor :initialized
13
13
  attr_accessor :downloads_path
14
14
  attr_accessor :endpoint
15
15
  attr_accessor :capabilities
16
+ attr_accessor :drivers
16
17
 
17
18
  def self.initialize_web_driver(options = nil)
19
+ @initialized ||= false
20
+ initialize_downloads unless @initialized
18
21
  @endpoint = nil
19
22
  @capabilities = nil
23
+ Environ.driver_name = nil
24
+ Environ.device_orientation = nil
20
25
  if options.is_a?(String)
21
26
  Capybara.app_host = options
22
27
  elsif options.is_a?(Hash)
23
28
  Capybara.app_host = options[:app_host] if options.key?(:app_host)
24
29
  @endpoint = options[:endpoint] if options.key?(:endpoint)
25
- @capabilities = options[:desired_capabilities] if options.key?(:desired_capabilities)
30
+ @capabilities = options[:capabilities] if options.key?(:capabilities)
31
+ Environ.driver = options[:driver] if options.key?(:driver)
32
+ Environ.driver_name = options[:driver_name] if options.key?(:driver_name)
33
+ Environ.device_type = options[:device_type] if options.key?(:device_type)
34
+ Environ.browser_size = if options.key?(:browser_size)
35
+ options[:browser_size]
36
+ else
37
+ ENV['BROWSER_SIZE'] if ENV['BROWSER_SIZE']
38
+ end
26
39
  end
27
40
  # determine browser type and driver
28
- Environ.browser = ENV['WEB_BROWSER'] if ENV['WEB_BROWSER']
29
- Environ.driver = if ENV['DRIVER']
30
- ENV['DRIVER'].downcase.to_sym
31
- else
32
- :webdriver
33
- end
34
- # set downloads folder path
35
- @downloads_path = "#{Dir.pwd}/downloads"
36
- if ENV['PARALLEL']
37
- # :nocov:
38
- Environ.parallel = true
39
- Environ.process_num = ENV['TEST_ENV_NUMBER']
40
- if Dir.exist?(@downloads_path)
41
- @downloads_path = "#{@downloads_path}/#{ENV['TEST_ENV_NUMBER']}"
42
- Dir.mkdir(@downloads_path) unless Dir.exist?(@downloads_path)
43
- end
44
- # :nocov:
41
+ if @capabilities.nil?
42
+ Environ.driver = ENV['DRIVER'].downcase.to_sym if ENV['DRIVER']
43
+ Environ.browser = ENV['WEB_BROWSER'] if ENV['WEB_BROWSER']
44
+ Environ.device_orientation = ENV['ORIENTATION'] if ENV['ORIENTATION']
45
45
  else
46
- Environ.parallel = false
46
+ Environ.browser = @capabilities[:browserName]
47
+ Environ.device_orientation = @capabilities[:orientation] if @capabilities[:orientation]
48
+ Environ.device_orientation = @capabilities[:'appium:orientation'] if @capabilities[:'appium:orientation']
47
49
  end
48
- @downloads_path = @downloads_path.tr('/', "\\") if OS.windows?
49
-
50
+ Environ.browser = Environ.browser.downcase.to_sym if Environ.browser.is_a?(String)
51
+ Environ.driver = :webdriver if Environ.driver.nil?
52
+ Environ.device_type = ENV['DEVICE_TYPE'] if ENV['DEVICE_TYPE']
50
53
  # assume that we're testing within a local desktop web browser
51
54
  Environ.platform = :desktop
52
55
  Environ.headless = false
@@ -57,55 +60,89 @@ module TestCentricity
57
60
  when :appium
58
61
  initialize_appium
59
62
  'Appium'
60
- # :nocov:
63
+ when :webdriver
64
+ initialize_local_browser
65
+ 'local browser instance'
66
+ when :selenium_grid, :grid
67
+ initialize_remote
68
+ 'Selenium Grid'
61
69
  when :browserstack
62
70
  initialize_browserstack
63
71
  'Browserstack cloud service'
64
- when :lambdatest
65
- initialize_lambdatest
66
- 'LambdaTest cloud service'
67
- when :saucelabs
68
- initialize_saucelabs
69
- 'Sauce Labs cloud service'
70
72
  when :testingbot
71
73
  initialize_testingbot
72
74
  'TestingBot cloud service'
73
- when :webdriver
74
- if ENV['SELENIUM'] == 'remote'
75
- initialize_remote
76
- 'Selenium Grid'
77
- else
78
- initialize_local_browser
79
- 'local browser instance'
80
- end
75
+ # :nocov:
76
+ when :saucelabs
77
+ initialize_saucelabs
78
+ 'Sauce Labs cloud service'
79
+ when :lambdatest
80
+ initialize_lambdatest
81
+ 'LambdaTest cloud service'
82
+ # :nocov:
83
+ else
84
+ raise "#{Environ.driver} is not a supported driver"
81
85
  end
82
86
 
83
87
  # set browser window size only if testing with a desktop web browser
84
- unless Environ.is_device? || Environ.is_simulator? || Capybara.current_driver == :appium
88
+ unless Environ.is_device? || Environ.is_simulator? || Environ.driver == :appium
85
89
  initialize_browser_size
86
90
  end
87
91
 
88
92
  # set Capybara's server port if PARALLEL_PORT is true
89
- Capybara.server_port = 9887 + ENV['TEST_ENV_NUMBER'].to_i if ENV['PARALLEL'] && ENV['PARALLEL_PORT']
93
+ Capybara.server_port = 9887 + ENV['TEST_ENV_NUMBER'].to_i if Environ.parallel
90
94
 
91
95
  Environ.session_state = :running
92
96
  puts "Using #{Environ.browser} browser via #{context}"
97
+ # add the new driver to the driver queue
98
+ @drivers[Environ.driver_name] = Environ.driver_state
93
99
  end
94
100
 
95
- def self.set_domain(url)
96
- Capybara.app_host = url
101
+ def self.activate_driver(driver_name)
102
+ driver_state = @drivers[driver_name]
103
+ raise "Could not find a driver named '#{driver_name}'" if driver_state.nil?
104
+
105
+ Environ.restore_driver_state(driver_state)
106
+ Capybara.current_driver = driver_name
107
+ Capybara.default_driver = driver_name
108
+ end
109
+
110
+ # Return the number of driver instances
111
+ #
112
+ # @return [Integer]
113
+ def self.num_drivers
114
+ @drivers.length
115
+ end
116
+
117
+ # Close all browsers and terminate all driver instances
118
+ def self.close_all_drivers
119
+ @drivers.each do |key, _value|
120
+ Environ.restore_driver_state(@drivers[key])
121
+ Capybara.current_driver = key
122
+ Capybara.default_driver = key
123
+ Capybara.page.driver.quit
124
+ Capybara.current_session.quit
125
+ @drivers.delete(key)
126
+ end
127
+ Capybara.reset_sessions!
128
+ Environ.session_state = :quit
129
+ Capybara.current_driver = nil
130
+ @drivers = {}
131
+ @initialized = false
97
132
  end
98
133
 
99
134
  def self.initialize_browser_size
100
- # tile browser windows if running in multiple parallel threads and BROWSER_TILE environment variable is true
101
- if ENV['PARALLEL'] && ENV['BROWSER_TILE']
102
- # :nocov:
103
- thread = ENV['TEST_ENV_NUMBER'].to_i
135
+ # tile browser windows if BROWSER_TILE environment variable is true and running in multiple parallel threads
136
+ if ENV['BROWSER_TILE'] && (Environ.parallel || @drivers.length > 1)
137
+ thread = if Environ.parallel
138
+ ENV['TEST_ENV_NUMBER'].to_i
139
+ else
140
+ @drivers.length
141
+ end
104
142
  if thread > 1
105
143
  Browsers.set_browser_window_position(100 * thread - 1, 100 * thread - 1)
106
144
  sleep(1)
107
145
  end
108
- # :nocov:
109
146
  else
110
147
  Browsers.set_browser_window_position(10, 10)
111
148
  sleep(1)
@@ -113,20 +150,30 @@ module TestCentricity
113
150
 
114
151
  browser = Environ.browser.to_s
115
152
  if Environ.is_desktop?
116
- if ENV['BROWSER_SIZE'] == 'max'
153
+ case
154
+ when ENV['BROWSER_SIZE'] == 'max'
117
155
  Browsers.maximize_browser
118
- elsif ENV['BROWSER_SIZE']
156
+ when ENV['BROWSER_SIZE']
119
157
  Browsers.set_browser_window_size(ENV['BROWSER_SIZE'])
158
+ when Environ.browser_size == 'max'
159
+ Browsers.maximize_browser
160
+ when Environ.browser_size
161
+ Browsers.set_browser_window_size(Environ.browser_size)
120
162
  else
121
- Browsers.set_browser_window_size(Browsers.browser_size(browser, ENV['ORIENTATION']))
163
+ Browsers.set_browser_window_size(Browsers.browser_size(browser, Environ.device_orientation))
122
164
  end
123
165
  elsif Environ.is_mobile? && !Environ.is_device?
124
- Browsers.set_browser_window_size(Browsers.browser_size(browser, ENV['ORIENTATION']))
166
+ Browsers.set_browser_window_size(Browsers.browser_size(browser, Environ.device_orientation))
125
167
  end
126
168
  Environ.session_state = :running
127
169
  end
128
170
 
129
171
  # :nocov:
172
+
173
+ def self.set_domain(url)
174
+ Capybara.app_host = url
175
+ end
176
+
130
177
  def self.close_tunnel
131
178
  unless @bs_local.nil?
132
179
  @bs_local.stop
@@ -141,174 +188,179 @@ module TestCentricity
141
188
 
142
189
  private
143
190
 
191
+ def self.initialize_downloads
192
+ @drivers = {}
193
+ # set downloads folder path
194
+ @downloads_path = "#{Dir.pwd}/downloads"
195
+ if ENV['PARALLEL']
196
+ Environ.parallel = true
197
+ Environ.process_num = ENV['TEST_ENV_NUMBER']
198
+ Environ.process_num = '1' if Environ.process_num.blank?
199
+ if Dir.exist?(@downloads_path)
200
+ @downloads_path = "#{@downloads_path}/#{Environ.process_num}"
201
+ Dir.mkdir(@downloads_path) unless Dir.exist?(@downloads_path)
202
+ end
203
+ else
204
+ Environ.parallel = false
205
+ end
206
+ @downloads_path = @downloads_path.tr('/', "\\") if OS.windows?
207
+ @initialized = true
208
+ end
209
+
144
210
  def self.initialize_appium
145
211
  Environ.platform = :mobile
146
212
  Environ.device = :simulator
147
- Environ.browser = ENV['APP_BROWSER']
148
- Environ.device_name = ENV['APP_DEVICE']
149
- Environ.device_os = ENV['APP_PLATFORM_NAME'].downcase.to_sym
150
- Environ.device_type = ENV['DEVICE_TYPE'] if ENV['DEVICE_TYPE']
151
- Environ.device_os_version = ENV['APP_VERSION']
152
- Environ.device_orientation = ENV['ORIENTATION'] if ENV['ORIENTATION']
153
- Capybara.default_driver = :appium
154
- Environ.driver = :appium
155
- # define capabilites
156
- desired_capabilities = if @capabilities.nil?
157
- desired_capabilities = {
158
- platformName: Environ.device_os,
159
- platformVersion: Environ.device_os_version,
160
- browserName: Environ.browser,
161
- deviceName: Environ.device_name
162
- }
163
- desired_capabilities[:avd] = ENV['APP_DEVICE'] if Environ.device_os == :android
164
- desired_capabilities[:automationName] = ENV['AUTOMATION_ENGINE'] if ENV['AUTOMATION_ENGINE']
165
- if ENV['UDID']
166
- # :nocov:
167
- Environ.device = :device
168
- desired_capabilities[:udid] = ENV['UDID']
169
- desired_capabilities[:xcodeOrgId] = ENV['TEAM_ID'] if ENV['TEAM_ID']
170
- desired_capabilities[:xcodeSigningId] = ENV['TEAM_NAME'] if ENV['TEAM_NAME']
171
- # :nocov:
172
- else
173
- desired_capabilities[:orientation] = Environ.device_orientation.upcase if Environ.device_orientation
174
- if Environ.device_os == :ios
175
- desired_capabilities[:language] = Environ.language if Environ.language
176
- desired_capabilities[:locale] = Environ.locale.gsub('-', '_') if Environ.locale
177
- end
178
- end
179
- desired_capabilities[:safariIgnoreFraudWarning] = ENV['APP_IGNORE_FRAUD_WARNING'] if ENV['APP_IGNORE_FRAUD_WARNING']
180
- desired_capabilities[:safariInitialUrl] = ENV['APP_INITIAL_URL'] if ENV['APP_INITIAL_URL']
181
- desired_capabilities[:safariAllowPopups] = ENV['APP_ALLOW_POPUPS'] if ENV['APP_ALLOW_POPUPS']
182
- desired_capabilities[:shutdownOtherSimulators] = ENV['SHUTDOWN_OTHER_SIMS'] if ENV['SHUTDOWN_OTHER_SIMS']
183
- desired_capabilities[:forceSimulatorSoftwareKeyboardPresence] = ENV['SHOW_SIM_KEYBOARD'] if ENV['SHOW_SIM_KEYBOARD']
184
-
185
- desired_capabilities[:autoAcceptAlerts] = ENV['AUTO_ACCEPT_ALERTS'] if ENV['AUTO_ACCEPT_ALERTS']
186
- desired_capabilities[:autoDismissAlerts] = ENV['AUTO_DISMISS_ALERTS'] if ENV['AUTO_DISMISS_ALERTS']
187
- desired_capabilities[:isHeadless] = ENV['HEADLESS'] if ENV['HEADLESS']
188
-
189
- desired_capabilities[:newCommandTimeout] = ENV['NEW_COMMAND_TIMEOUT'] if ENV['NEW_COMMAND_TIMEOUT']
190
- desired_capabilities[:noReset] = ENV['APP_NO_RESET'] if ENV['APP_NO_RESET']
191
- desired_capabilities[:fullReset] = ENV['APP_FULL_RESET'] if ENV['APP_FULL_RESET']
192
- desired_capabilities[:webkitDebugProxyPort] = ENV['WEBKIT_DEBUG_PROXY_PORT'] if ENV['WEBKIT_DEBUG_PROXY_PORT']
193
- desired_capabilities[:webDriverAgentUrl] = ENV['WEBDRIVER_AGENT_URL'] if ENV['WEBDRIVER_AGENT_URL']
194
- desired_capabilities[:usePrebuiltWDA] = ENV['USE_PREBUILT_WDA'] if ENV['USE_PREBUILT_WDA']
195
- desired_capabilities[:useNewWDA] = ENV['USE_NEW_WDA'] if ENV['USE_NEW_WDA']
196
- desired_capabilities[:chromedriverExecutable] = ENV['CHROMEDRIVER_EXECUTABLE'] if ENV['CHROMEDRIVER_EXECUTABLE']
197
- # set wdaLocalPort (iOS) or systemPort (Android) if PARALLEL_PORT is true
198
- if ENV['PARALLEL'] && ENV['PARALLEL_PORT']
199
- # :nocov:
200
- if Environ.device_os == :ios
201
- desired_capabilities[:wdaLocalPort] = 8100 + ENV['TEST_ENV_NUMBER'].to_i
202
- else
203
- desired_capabilities[:systemPort] = 8200 + ENV['TEST_ENV_NUMBER'].to_i
204
- end
205
- # :nocov:
206
- else
207
- desired_capabilities[:wdaLocalPort] = ENV['WDA_LOCAL_PORT'] if ENV['WDA_LOCAL_PORT']
208
- desired_capabilities[:systemPort] = ENV['SYSTEM_PORT'] if ENV['SYSTEM_PORT']
209
- end
210
- desired_capabilities
211
- else
212
- @capabilities
213
- end
213
+ # define capabilities
214
+ caps = if @capabilities.nil?
215
+ Environ.browser = ENV['APP_BROWSER']
216
+ Environ.device_name = ENV['APP_DEVICE']
217
+ Environ.device_os = ENV['APP_PLATFORM_NAME'].downcase.to_sym
218
+ Environ.device_os_version = ENV['APP_VERSION']
219
+ caps = {
220
+ platformName: Environ.device_os,
221
+ browserName: Environ.browser,
222
+ 'appium:platformVersion': Environ.device_os_version,
223
+ 'appium:deviceName': Environ.device_name
224
+ }
225
+ caps[:'appium:avd'] = ENV['APP_DEVICE'] if Environ.device_os == :android
226
+ caps[:'appium:automationName'] = ENV['AUTOMATION_ENGINE'] if ENV['AUTOMATION_ENGINE']
227
+ if ENV['UDID']
228
+ # :nocov:
229
+ Environ.device = :device
230
+ caps[:'appium:udid'] = ENV['UDID']
231
+ caps[:'appium:xcodeOrgId'] = ENV['TEAM_ID'] if ENV['TEAM_ID']
232
+ caps[:'appium:xcodeSigningId'] = ENV['TEAM_NAME'] if ENV['TEAM_NAME']
233
+ # :nocov:
234
+ else
235
+ caps[:'appium:orientation'] = Environ.device_orientation.upcase if Environ.device_orientation
236
+ if Environ.device_os == :ios
237
+ caps[:'appium:language'] = Environ.language if Environ.language
238
+ caps[:'appium:locale'] = Environ.locale.gsub('-', '_') if Environ.locale
239
+ end
240
+ end
241
+ caps[:'appium:safariIgnoreFraudWarning'] = ENV['APP_IGNORE_FRAUD_WARNING'] if ENV['APP_IGNORE_FRAUD_WARNING']
242
+ caps[:'appium:safariInitialUrl'] = ENV['APP_INITIAL_URL'] if ENV['APP_INITIAL_URL']
243
+ caps[:'appium:safariAllowPopups'] = ENV['APP_ALLOW_POPUPS'] if ENV['APP_ALLOW_POPUPS']
244
+ caps[:'appium:shutdownOtherSimulators'] = ENV['SHUTDOWN_OTHER_SIMS'] if ENV['SHUTDOWN_OTHER_SIMS']
245
+ caps[:'appium:forceSimulatorSoftwareKeyboardPresence'] = ENV['SHOW_SIM_KEYBOARD'] if ENV['SHOW_SIM_KEYBOARD']
246
+
247
+ caps[:'appium:autoAcceptAlerts'] = ENV['AUTO_ACCEPT_ALERTS'] if ENV['AUTO_ACCEPT_ALERTS']
248
+ caps[:'appium:autoDismissAlerts'] = ENV['AUTO_DISMISS_ALERTS'] if ENV['AUTO_DISMISS_ALERTS']
249
+ caps[:'appium:isHeadless'] = ENV['HEADLESS'] if ENV['HEADLESS']
250
+
251
+ caps[:'appium:newCommandTimeout'] = ENV['NEW_COMMAND_TIMEOUT'] if ENV['NEW_COMMAND_TIMEOUT']
252
+ caps[:'appium:noReset'] = ENV['APP_NO_RESET'] if ENV['APP_NO_RESET']
253
+ caps[:'appium:fullReset'] = ENV['APP_FULL_RESET'] if ENV['APP_FULL_RESET']
254
+ caps[:'appium:webkitDebugProxyPort'] = ENV['WEBKIT_DEBUG_PROXY_PORT'] if ENV['WEBKIT_DEBUG_PROXY_PORT']
255
+ caps[:'appium:webDriverAgentUrl'] = ENV['WEBDRIVER_AGENT_URL'] if ENV['WEBDRIVER_AGENT_URL']
256
+ caps[:'appium:usePrebuiltWDA'] = ENV['USE_PREBUILT_WDA'] if ENV['USE_PREBUILT_WDA']
257
+ caps[:'appium:useNewWDA'] = ENV['USE_NEW_WDA'] if ENV['USE_NEW_WDA']
258
+ caps[:'appium:chromedriverExecutable'] = ENV['CHROMEDRIVER_EXECUTABLE'] if ENV['CHROMEDRIVER_EXECUTABLE']
259
+ # set wdaLocalPort (iOS) or systemPort (Android) if PARALLEL_PORT is true
260
+ if Environ.parallel
261
+ # :nocov:
262
+ if Environ.device_os == :ios
263
+ caps[:'appium:wdaLocalPort'] = 8100 + ENV['TEST_ENV_NUMBER'].to_i
264
+ else
265
+ caps[:'appium:systemPort'] = 8200 + ENV['TEST_ENV_NUMBER'].to_i
266
+ end
267
+ # :nocov:
268
+ else
269
+ caps[:'appium:wdaLocalPort'] = ENV['WDA_LOCAL_PORT'] if ENV['WDA_LOCAL_PORT']
270
+ caps[:'appium:systemPort'] = ENV['SYSTEM_PORT'] if ENV['SYSTEM_PORT']
271
+ end
272
+ caps
273
+ else
274
+ Environ.device_os = @capabilities[:platformName]
275
+ Environ.device_os_version = @capabilities[:'appium:platformVersion']
276
+ Environ.device_name = @capabilities[:'appium:deviceName']
277
+ @capabilities
278
+ end
214
279
  # specify endpoint url
215
280
  @endpoint = 'http://localhost:4723/wd/hub' if @endpoint.nil?
216
281
 
217
- Capybara.register_driver(:appium) do |app|
218
- all_options = {
219
- appium_lib: { server_url: @endpoint },
220
- caps: desired_capabilities
221
- }
222
- Appium::Capybara::Driver.new(app, all_options)
223
- end
282
+ register_remote_driver(Environ.browser, caps)
224
283
  end
225
284
 
226
285
  def self.initialize_local_browser
227
286
  Environ.os = case
228
287
  when OS.osx?
229
288
  'OS X'
289
+ # :nocov:
230
290
  when OS.windows?
231
291
  'Windows'
232
292
  when OS.linux?
233
293
  'Linux'
234
294
  else
235
295
  'unknown'
296
+ # :nocov:
236
297
  end
237
- browser = Environ.browser.downcase.to_sym
238
-
239
- case browser
240
- when :firefox, :chrome, :ie, :safari, :edge
298
+ case Environ.browser
299
+ when :firefox, :chrome, :safari, :edge, :chrome_headless, :firefox_headless, :edge_headless
241
300
  Environ.platform = :desktop
242
- when :chrome_headless, :firefox_headless, :edge_headless
243
- Environ.platform = :desktop
244
- Environ.headless = true
245
301
  else
246
302
  Environ.platform = :mobile
247
303
  Environ.device_name = Browsers.mobile_device_name(Environ.browser)
248
304
  end
249
305
 
250
- Capybara.register_driver :selenium do |app|
306
+ Capybara.register_driver driver_name do |app|
307
+ browser = Environ.browser
251
308
  case browser
252
- when :safari, :ie
309
+ when :safari
253
310
  Capybara::Selenium::Driver.new(app, browser: browser)
254
311
  when :firefox, :firefox_headless
255
312
  options = firefox_options(browser)
256
- Capybara::Selenium::Driver.new(app, browser: :firefox, capabilities: [options])
313
+ Capybara::Selenium::Driver.new(app, browser: :firefox, options: options)
257
314
  when :chrome, :chrome_headless
258
315
  options = chrome_edge_options(browser)
259
- Capybara::Selenium::Driver.new(app, browser: :chrome, capabilities: [options])
316
+ Capybara::Selenium::Driver.new(app, browser: :chrome, options: options)
260
317
  when :edge, :edge_headless
261
318
  options = chrome_edge_options(browser)
262
- Capybara::Selenium::Driver.new(app, browser: :edge, capabilities: [options])
319
+ Capybara::Selenium::Driver.new(app, browser: :edge, options: options)
263
320
  else
264
- if ENV['HOST_BROWSER'] && ENV['HOST_BROWSER'].downcase.to_sym == :chrome
265
- user_agent = Browsers.mobile_device_agent(Environ.browser)
266
- options = Selenium::WebDriver::Chrome::Options.new
267
- options.add_argument('--disable-dev-shm-usage')
268
- options.add_argument("--user-agent='#{user_agent}'")
269
- options.add_argument("--lang=#{ENV['LOCALE']}") if ENV['LOCALE']
270
- Capybara::Selenium::Driver.new(app, browser: :chrome, capabilities: [options])
271
- else
272
- raise "Requested browser '#{browser}' is not supported"
273
- end
321
+ user_agent = Browsers.mobile_device_agent(Environ.browser)
322
+ options = Selenium::WebDriver::Chrome::Options.new(exclude_switches: ['enable-automation'])
323
+ options.add_argument('--disable-dev-shm-usage')
324
+ options.add_argument("--user-agent='#{user_agent}'")
325
+ options.add_argument("--lang=#{ENV['LOCALE']}") if ENV['LOCALE']
326
+ Capybara::Selenium::Driver.new(app, browser: :chrome, options: options)
274
327
  end
275
328
  end
276
- Capybara.default_driver = :selenium
329
+ Capybara.default_driver = Environ.driver_name
277
330
  end
278
331
 
279
332
  def self.initialize_remote
280
333
  Environ.grid = :selenium_grid
281
- browser = Environ.browser.downcase.to_sym
282
- @endpoint = ENV['REMOTE_ENDPOINT'] || 'http://127.0.0.1:4444/wd/hub' if @endpoint.nil?
283
-
334
+ browser = Environ.browser
335
+ @endpoint = if @endpoint.nil?
336
+ ENV['REMOTE_ENDPOINT'] if ENV['REMOTE_ENDPOINT']
337
+ else
338
+ 'http://localhost:4444/wd/hub'
339
+ end
284
340
  case browser
341
+ # :nocov:
285
342
  when :safari
286
343
  options = Selenium::WebDriver::Safari::Options.new
287
- when :ie
288
- options = Selenium::WebDriver::IE::Options.new
344
+ # :nocov:
289
345
  when :firefox, :firefox_headless
290
346
  options = firefox_options(browser)
291
347
  when :chrome, :chrome_headless, :edge, :edge_headless
292
348
  options = chrome_edge_options(browser)
293
349
  else
294
- if ENV['HOST_BROWSER'] && ENV['HOST_BROWSER'].downcase.to_sym == :chrome
295
- Environ.platform = :mobile
296
- Environ.device_name = Browsers.mobile_device_name(Environ.browser)
297
- user_agent = Browsers.mobile_device_agent(Environ.browser)
298
- options = Selenium::WebDriver::Chrome::Options.new
299
- options.add_argument('--disable-dev-shm-usage')
300
- options.add_argument("--user-agent='#{user_agent}'")
301
- options.add_argument("--lang=#{ENV['LOCALE']}") if ENV['LOCALE']
302
- else
303
- raise "Requested browser '#{browser}' is not supported on Selenium Grid"
304
- end
350
+ Environ.platform = :mobile
351
+ Environ.device_name = Browsers.mobile_device_name(Environ.browser)
352
+ user_agent = Browsers.mobile_device_agent(Environ.browser)
353
+ options = Selenium::WebDriver::Chrome::Options.new
354
+ options.add_argument('--disable-dev-shm-usage')
355
+ options.add_argument("--user-agent='#{user_agent}'")
356
+ options.add_argument("--lang=#{ENV['LOCALE']}") if ENV['LOCALE']
305
357
  end
306
358
 
307
- Capybara.register_driver :remote_browser do |app|
359
+ Capybara.register_driver driver_name do |app|
308
360
  Capybara::Selenium::Driver.new(app,
309
361
  browser: :remote,
310
362
  url: @endpoint,
311
- capabilities: [options]).tap do |driver|
363
+ options: options).tap do |driver|
312
364
  # configure file_detector for remote uploads
313
365
  driver.browser.file_detector = lambda do |args|
314
366
  str = args.first.to_s
@@ -316,30 +368,32 @@ module TestCentricity
316
368
  end
317
369
  end
318
370
  end
319
- Capybara.current_driver = :remote_browser
320
- Capybara.default_driver = :remote_browser
371
+ Capybara.current_driver = Environ.driver_name
372
+ Capybara.default_driver = Environ.driver_name
321
373
  end
322
374
 
323
- # :nocov:
324
375
  def self.initialize_browserstack
325
- browser = ENV['BS_BROWSER']
376
+ # determine browser type
377
+ Environ.browser = if @capabilities.nil?
378
+ ENV['BS_BROWSER'] if ENV['BS_BROWSER']
379
+ else
380
+ @capabilities[:browserName]
381
+ end
382
+ browser = Environ.browser
326
383
  Environ.grid = :browserstack
327
-
328
384
  if ENV['BS_REAL_MOBILE'] || ENV['BS_DEVICE']
329
385
  Environ.platform = :mobile
330
386
  Environ.device_name = ENV['BS_DEVICE']
331
387
  Environ.device_os = ENV['BS_OS']
332
- Environ.device_orientation = ENV['ORIENTATION'] if ENV['ORIENTATION']
333
388
  Environ.device = if ENV['BS_REAL_MOBILE']
334
389
  :device
335
390
  else
336
391
  :simulator
337
392
  end
338
- elsif ENV['BS_OS']
339
- Environ.os = "#{ENV['BS_OS']} #{ENV['BS_OS_VERSION']}"
340
393
  end
341
394
  # specify endpoint url
342
- @endpoint = "http://#{ENV['BS_USERNAME']}:#{ENV['BS_AUTHKEY']}@hub-cloud.browserstack.com/wd/hub" if @endpoint.nil?
395
+ @endpoint = "https://#{ENV['BS_USERNAME']}:#{ENV['BS_AUTHKEY']}@hub-cloud.browserstack.com/wd/hub" if @endpoint.nil?
396
+ # :nocov:
343
397
  # enable tunneling if specified
344
398
  if ENV['TUNNELING']
345
399
  @bs_local = BrowserStack::Local.new
@@ -351,8 +405,10 @@ module TestCentricity
351
405
  puts 'BrowserStack Local instance failed to start'
352
406
  end
353
407
  end
408
+ # :nocov:
354
409
  # define BrowserStack options
355
410
  options = if @capabilities.nil?
411
+ Environ.os = "#{ENV['BS_OS']} #{ENV['BS_OS_VERSION']}"
356
412
  browser_options = {}
357
413
  # define the required set of BrowserStack options
358
414
  bs_options = {
@@ -399,7 +455,7 @@ module TestCentricity
399
455
  else
400
456
  # define desktop browser options
401
457
  bs_options[:resolution] = ENV['RESOLUTION'] if ENV['RESOLUTION']
402
- bs_options[:seleniumVersion] = '4.3.0'
458
+ bs_options[:seleniumVersion] = '4.15.0'
403
459
  {
404
460
  browserName: browser,
405
461
  browserVersion: ENV['BS_VERSION'],
@@ -407,87 +463,122 @@ module TestCentricity
407
463
  }
408
464
  end
409
465
  else
466
+ bs_options = @capabilities[:'bstack:options']
467
+ Environ.os = "#{bs_options[:os]} #{bs_options[:osVersion]}"
468
+ if bs_options.key?(:deviceName)
469
+ Environ.platform = :mobile
470
+ Environ.device_name = bs_options[:deviceName]
471
+ Environ.device_os = bs_options[:osVersion]
472
+ Environ.device = if bs_options.key?(:realMobile)
473
+ :device
474
+ else
475
+ :simulator
476
+ end
477
+ Environ.device_orientation = bs_options[:deviceOrientation] if bs_options.key?(:deviceOrientation)
478
+ end
410
479
  @capabilities
411
480
  end
412
- register_remote_driver(:browserstack, browser, options)
413
- # configure file_detector for remote uploads
414
- config_file_uploads
481
+ register_remote_driver(browser, options)
482
+ # configure file_detector for remote uploads if target is desktop web browser
483
+ config_file_uploads if Environ.platform == :desktop
415
484
  Environ.tunneling = ENV['TUNNELING'] if ENV['TUNNELING']
416
- Environ.device_type = ENV['DEVICE_TYPE'] if ENV['DEVICE_TYPE']
417
485
  end
418
486
 
419
- def self.initialize_lambdatest
420
- browser = ENV['LT_BROWSER']
421
- Environ.grid = :lambdatest
422
- Environ.os = ENV['LT_OS']
423
- Environ.platform = :desktop
424
- Environ.tunneling = ENV['TUNNELING'] if ENV['TUNNELING']
487
+ def self.initialize_testingbot
488
+ # determine browser type
489
+ Environ.browser = if @capabilities.nil?
490
+ ENV['TB_BROWSER'] if ENV['TB_BROWSER']
491
+ else
492
+ @capabilities[:browserName]
493
+ end
494
+ browser = Environ.browser
495
+ Environ.grid = :testingbot
496
+ if ENV['TB_PLATFORM']
497
+ Environ.device_os = ENV['TB_PLATFORM']
498
+ Environ.device_name = ENV['TB_DEVICE']
499
+ Environ.platform = :mobile
500
+ Environ.device = :simulator
501
+ else
502
+ Environ.platform = :desktop
503
+ end
425
504
  # specify endpoint url
426
- @endpoint = "https://#{ENV['LT_USERNAME']}:#{ENV['LT_AUTHKEY']}@hub.lambdatest.com/wd/hub" if @endpoint.nil?
427
- # define LambdaTest options
505
+ if @endpoint.nil?
506
+ url = ENV['TUNNELING'] ? '@localhost:4445/wd/hub' : '@hub.testingbot.com/wd/hub'
507
+ @endpoint = "https://#{ENV['TB_USERNAME']}:#{ENV['TB_AUTHKEY']}#{url}"
508
+ end
509
+ # define TestingBot options
428
510
  options = if @capabilities.nil?
429
- # define the required set of LambdaTest options
430
- lt_options = {
431
- user: ENV['LT_USERNAME'],
432
- accessKey: ENV['LT_AUTHKEY'],
433
- build: test_context_message,
434
- platformName: ENV['LT_OS'],
435
- resolution: ENV['RESOLUTION'],
436
- selenium_version: '4.0.0',
437
- }
438
- # define the optional LambdaTest options
439
- lt_options[:name] = ENV['AUTOMATE_PROJECT'] if ENV['AUTOMATE_PROJECT']
440
- lt_options[:headless] = ENV['HEADLESS'] if ENV['HEADLESS']
441
- lt_options[:timezone] = ENV['TIME_ZONE'] if ENV['TIME_ZONE']
442
- lt_options[:geoLocation] = ENV['GEO_LOCATION'] if ENV['GEO_LOCATION']
443
- lt_options[:video] = ENV['RECORD_VIDEO'] if ENV['RECORD_VIDEO']
444
- lt_options[:visual] = ENV['SCREENSHOTS'] if ENV['SCREENSHOTS']
445
- lt_options[:network] = ENV['NETWORK_LOGS'] if ENV['NETWORK_LOGS']
446
- lt_options[:tunnel] = ENV['TUNNELING'] if ENV['TUNNELING']
447
- # define browser specific LambdaTest options
448
- case browser.downcase.to_sym
449
- when :safari
450
- lt_options['safari.popups'] = ENV['ALLOW_POPUPS'] if ENV['ALLOW_POPUPS']
451
- lt_options['safari.cookies'] = ENV['ALLOW_COOKIES'] if ENV['ALLOW_COOKIES']
452
- when :ie
453
- lt_options['ie.popups'] = ENV['ALLOW_POPUPS'] if ENV['ALLOW_POPUPS']
454
- when :microsoftedge
455
- lt_options['edge.popups'] = ENV['ALLOW_POPUPS'] if ENV['ALLOW_POPUPS']
511
+ Environ.os = ENV['TB_OS']
512
+ # define the required set of TestingBot options
513
+ tb_options = { build: test_context_message }
514
+ # define the optional TestingBot options
515
+ tb_options[:name] = ENV['AUTOMATE_PROJECT'] if ENV['AUTOMATE_PROJECT']
516
+ tb_options[:timeZone] = ENV['TIME_ZONE'] if ENV['TIME_ZONE']
517
+ tb_options['testingbot.geoCountryCode'] = ENV['GEO_LOCATION'] if ENV['GEO_LOCATION']
518
+ tb_options[:screenrecorder] = ENV['RECORD_VIDEO'] if ENV['RECORD_VIDEO']
519
+ tb_options[:screenshot] = ENV['SCREENSHOTS'] if ENV['SCREENSHOTS']
520
+ # define mobile device options
521
+ if ENV['TB_PLATFORM']
522
+ tb_options[:platform] = ENV['TB_PLATFORM']
523
+ tb_options[:orientation] = ENV['ORIENTATION'].upcase if ENV['ORIENTATION']
524
+ tb_options[:deviceName] = ENV['TB_DEVICE'] if ENV['TB_DEVICE']
525
+ else
526
+ # define desktop browser options
527
+ tb_options['screen-resolution'] = ENV['RESOLUTION'] if ENV['RESOLUTION']
528
+ tb_options['selenium-version'] = '4.14.1'
456
529
  end
457
530
  {
458
531
  browserName: browser,
459
- browserVersion: ENV['LT_VERSION'],
460
- 'LT:Options': lt_options
532
+ browserVersion: ENV['TB_VERSION'],
533
+ platformName: ENV['TB_OS'],
534
+ 'tb:options': tb_options
461
535
  }
462
536
  else
537
+ tb_options = @capabilities[:'tb:options']
538
+ Environ.os = @capabilities[:platformName]
539
+ if tb_options.key?(:deviceName)
540
+ Environ.platform = :mobile
541
+ Environ.device_name = tb_options[:deviceName]
542
+ Environ.device_os = @capabilities[:browserVersion]
543
+ Environ.device_orientation = tb_options[:orientation] if tb_options.key?(:orientation)
544
+ Environ.device = :simulator
545
+ end
463
546
  @capabilities
464
547
  end
465
- register_remote_driver(:lambdatest, browser, options)
466
- # configure file_detector for remote uploads
467
- config_file_uploads
548
+ register_remote_driver(browser, options)
549
+ # configure file_detector for remote uploads if target is desktop web browser
550
+ config_file_uploads if Environ.platform == :desktop
468
551
  end
469
552
 
553
+ # :nocov:
470
554
  def self.initialize_saucelabs
471
- browser = ENV['SL_BROWSER']
555
+ # determine browser type
556
+ Environ.browser = if @capabilities.nil?
557
+ ENV['SL_BROWSER'] if ENV['SL_BROWSER']
558
+ else
559
+ @capabilities[:browserName]
560
+ end
561
+ browser = Environ.browser
472
562
  Environ.grid = :saucelabs
473
563
 
474
- if ENV['SL_OS']
475
- Environ.platform = :desktop
476
- Environ.os = ENV['SL_OS']
477
- elsif ENV['SL_PLATFORM']
564
+ if ENV['SL_PLATFORM']
478
565
  Environ.device_name = ENV['SL_DEVICE']
479
566
  Environ.platform = :mobile
480
- Environ.device_orientation = ENV['ORIENTATION'] if ENV['ORIENTATION']
481
567
  Environ.device = :simulator
568
+ elsif ENV['SL_OS']
569
+ Environ.platform = :desktop
570
+ Environ.os = ENV['SL_OS']
482
571
  end
483
572
  # specify endpoint url
484
- @endpoint = "https://#{ENV['SL_USERNAME']}:#{ENV['SL_AUTHKEY']}@ondemand.#{ENV['DATA_CENTER']}.saucelabs.com/wd/hub" if @endpoint.nil?
573
+ if @endpoint.nil?
574
+ @endpoint = "https://#{ENV['SL_USERNAME']}:#{ENV['SL_AUTHKEY']}@ondemand.#{ENV['DATA_CENTER']}.saucelabs.com:443/wd/hub"
575
+ end
485
576
  # define SauceLab options
486
577
  options = if @capabilities.nil?
487
578
  # define the required set of SauceLab options
488
579
  sl_options = {
489
- userName: ENV['SL_USERNAME'],
490
- accessKey: ENV['SL_AUTHKEY'],
580
+ username: ENV['SL_USERNAME'],
581
+ access_key: ENV['SL_AUTHKEY'],
491
582
  build: test_context_message
492
583
  }
493
584
  # define the optional SauceLab options
@@ -497,12 +588,13 @@ module TestCentricity
497
588
  # define mobile device options
498
589
  if ENV['SL_PLATFORM']
499
590
  sl_options[:deviceOrientation] = ENV['ORIENTATION'].upcase if ENV['ORIENTATION']
500
- sl_options[:appiumVersion] = '1.22.3'
591
+ sl_options[:appium_version] = '1.22.3'
501
592
  {
502
593
  browserName: browser,
503
- platformName: ENV['SL_PLATFORM'],
594
+ platform_name: ENV['SL_PLATFORM'],
504
595
  'appium:deviceName': ENV['SL_DEVICE'],
505
596
  'appium:platformVersion': ENV['SL_VERSION'],
597
+ 'appium:automationName': ENV['AUTOMATION_ENGINE'],
506
598
  'sauce:options': sl_options
507
599
  }
508
600
  else
@@ -510,80 +602,95 @@ module TestCentricity
510
602
  sl_options[:screenResolution] = ENV['RESOLUTION'] if ENV['RESOLUTION']
511
603
  {
512
604
  browserName: browser,
513
- browserVersion: ENV['SL_VERSION'],
514
- platformName: ENV['SL_OS'],
605
+ browser_version: ENV['SL_VERSION'],
606
+ platform_name: ENV['SL_OS'],
515
607
  'sauce:options': sl_options
516
608
  }
517
609
  end
518
610
  else
611
+ sl_options = @capabilities[:'sauce:options']
612
+ Environ.os = @capabilities[:platform_name]
613
+ if @capabilities.key?(:'appium:deviceName')
614
+ Environ.platform = :mobile
615
+ Environ.device_name = @capabilities[:'appium:deviceName']
616
+ Environ.device_os = @capabilities[:'appium:platformVersion']
617
+ Environ.device = :simulator
618
+ Environ.device_orientation = sl_options[:deviceOrientation] if sl_options.key?(:deviceOrientation)
619
+ end
519
620
  @capabilities
520
621
  end
521
- register_remote_driver(:saucelabs, browser, options)
622
+ register_remote_driver(browser, options)
522
623
  # configure file_detector for remote uploads
523
- config_file_uploads
624
+ config_file_uploads if Environ.platform == :desktop
524
625
  end
525
626
 
526
- def self.initialize_testingbot
527
- browser = ENV['TB_BROWSER']
528
- Environ.grid = :testingbot
529
-
530
- Environ.os = ENV['TB_OS']
531
- if ENV['TB_PLATFORM']
532
- Environ.device_orientation = ENV['ORIENTATION'] if ENV['ORIENTATION']
533
- Environ.device_os = ENV['TB_PLATFORM']
534
- Environ.device_name = ENV['TB_DEVICE']
535
- Environ.device = :device
536
- Environ.platform = :mobile
537
- Environ.device_type = ENV['DEVICE_TYPE'] if ENV['DEVICE_TYPE']
538
- else
539
- Environ.platform = :desktop
540
- end
627
+ def self.initialize_lambdatest
628
+ # determine browser type
629
+ Environ.browser = if @capabilities.nil?
630
+ ENV['LT_BROWSER'] if ENV['LT_BROWSER']
631
+ else
632
+ @capabilities[:browserName]
633
+ end
634
+ browser = Environ.browser
635
+ Environ.grid = :lambdatest
636
+ Environ.platform = :desktop
637
+ Environ.tunneling = ENV['TUNNELING'] if ENV['TUNNELING']
541
638
  # specify endpoint url
542
- if @endpoint.nil?
543
- url = ENV['TUNNELING'] ? '@localhost:4445/wd/hub' : '@hub.testingbot.com/wd/hub'
544
- @endpoint = "http://#{ENV['TB_USERNAME']}:#{ENV['TB_AUTHKEY']}#{url}"
545
- end
546
- # define TestingBot options
639
+ @endpoint = "https://#{ENV['LT_USERNAME']}:#{ENV['LT_AUTHKEY']}@hub.lambdatest.com/wd/hub" if @endpoint.nil?
640
+ # define LambdaTest options
547
641
  options = if @capabilities.nil?
548
- # define the required set of TestingBot options
549
- tb_options = { build: test_context_message }
550
- # define the optional TestingBot options
551
- tb_options[:name] = ENV['AUTOMATE_PROJECT'] if ENV['AUTOMATE_PROJECT']
552
- tb_options[:timeZone] = ENV['TIME_ZONE'] if ENV['TIME_ZONE']
553
- tb_options['testingbot.geoCountryCode'] = ENV['GEO_LOCATION'] if ENV['GEO_LOCATION']
554
- tb_options[:screenrecorder] = ENV['RECORD_VIDEO'] if ENV['RECORD_VIDEO']
555
- tb_options[:screenshot] = ENV['SCREENSHOTS'] if ENV['SCREENSHOTS']
556
- # define mobile device options
557
- if ENV['TB_PLATFORM']
558
- tb_options[:platform] = ENV['TB_PLATFORM']
559
- tb_options[:orientation] = ENV['ORIENTATION'].upcase if ENV['ORIENTATION']
560
- tb_options[:deviceName] = ENV['TB_DEVICE'] if ENV['TB_DEVICE']
561
- else
562
- # define desktop browser options
563
- tb_options['screen-resolution'] = ENV['RESOLUTION'] if ENV['RESOLUTION']
564
- tb_options['selenium-version'] = '4.1.0'
642
+ Environ.os = ENV['LT_OS']
643
+ # define the required set of LambdaTest options
644
+ lt_options = {
645
+ user: ENV['LT_USERNAME'],
646
+ accessKey: ENV['LT_AUTHKEY'],
647
+ build: test_context_message,
648
+ platformName: ENV['LT_OS'],
649
+ resolution: ENV['RESOLUTION'],
650
+ selenium_version: '4.13.0',
651
+ }
652
+ # define the optional LambdaTest options
653
+ lt_options[:name] = ENV['AUTOMATE_PROJECT'] if ENV['AUTOMATE_PROJECT']
654
+ lt_options[:headless] = ENV['HEADLESS'] if ENV['HEADLESS']
655
+ lt_options[:timezone] = ENV['TIME_ZONE'] if ENV['TIME_ZONE']
656
+ lt_options[:geoLocation] = ENV['GEO_LOCATION'] if ENV['GEO_LOCATION']
657
+ lt_options[:video] = ENV['RECORD_VIDEO'] if ENV['RECORD_VIDEO']
658
+ lt_options[:visual] = ENV['SCREENSHOTS'] if ENV['SCREENSHOTS']
659
+ lt_options[:network] = ENV['NETWORK_LOGS'] if ENV['NETWORK_LOGS']
660
+ lt_options[:tunnel] = ENV['TUNNELING'] if ENV['TUNNELING']
661
+ # define browser specific LambdaTest options
662
+ case browser.downcase.to_sym
663
+ when :safari
664
+ lt_options['safari.popups'] = ENV['ALLOW_POPUPS'] if ENV['ALLOW_POPUPS']
665
+ lt_options['safari.cookies'] = ENV['ALLOW_COOKIES'] if ENV['ALLOW_COOKIES']
666
+ when :ie
667
+ lt_options['ie.popups'] = ENV['ALLOW_POPUPS'] if ENV['ALLOW_POPUPS']
668
+ when :microsoftedge
669
+ lt_options['edge.popups'] = ENV['ALLOW_POPUPS'] if ENV['ALLOW_POPUPS']
565
670
  end
566
671
  {
567
672
  browserName: browser,
568
- browserVersion: ENV['TB_VERSION'],
569
- platformName: ENV['TB_OS'],
570
- 'tb:options': tb_options
673
+ browserVersion: ENV['LT_VERSION'],
674
+ 'LT:Options': lt_options
571
675
  }
572
676
  else
677
+ Environ.os = @capabilities[:platform_name]
573
678
  @capabilities
574
679
  end
575
- register_remote_driver(:testingbot, browser, options)
576
- # configure file_detector for remote uploads if target is desktop web browser
577
- config_file_uploads unless ENV['TB_PLATFORM']
680
+ register_remote_driver(browser, options)
681
+ # configure file_detector for remote uploads
682
+ config_file_uploads if Environ.platform == :desktop
578
683
  end
579
684
  # :nocov:
580
685
 
581
686
  def self.chrome_edge_options(browser)
582
687
  options = case browser
583
688
  when :chrome, :chrome_headless
584
- Selenium::WebDriver::Chrome::Options.new
689
+ Selenium::WebDriver::Chrome::Options.new(exclude_switches: ['enable-automation'])
585
690
  when :edge, :edge_headless
586
- Selenium::WebDriver::Edge::Options.new
691
+ Selenium::WebDriver::Edge::Options.new(exclude_switches: ['enable-automation'])
692
+ else
693
+ raise "#{browser} is not a valid selector"
587
694
  end
588
695
  prefs = {
589
696
  prompt_for_download: false,
@@ -591,12 +698,15 @@ module TestCentricity
591
698
  default_directory: @downloads_path
592
699
  }
593
700
  options.add_preference(:download, prefs)
701
+ options.add_argument('--force-device-scale-factor=1')
702
+ options.add_argument('--disable-geolocation')
594
703
  options.add_argument('--disable-dev-shm-usage')
704
+ options.add_argument('--no-sandbox')
595
705
  options.add_argument("--lang=#{ENV['LOCALE']}") if ENV['LOCALE']
596
706
  if browser == :chrome_headless || browser == :edge_headless
707
+ Environ.headless = true
597
708
  options.add_argument('--headless')
598
709
  options.add_argument('--disable-gpu')
599
- options.add_argument('--no-sandbox')
600
710
  end
601
711
  options
602
712
  end
@@ -618,18 +728,20 @@ module TestCentricity
618
728
 
619
729
  profile['intl.accept_languages'] = ENV['LOCALE'] if ENV['LOCALE']
620
730
  options = Selenium::WebDriver::Firefox::Options.new(profile: profile)
621
- options.args << '--headless' if browser == :firefox_headless
731
+ if browser == :firefox_headless
732
+ Environ.headless = true
733
+ options.args << '--headless'
734
+ end
622
735
  options
623
736
  end
624
737
 
625
- # :nocov:
626
738
  def self.test_context_message
627
739
  context_message = if ENV['TEST_CONTEXT']
628
740
  "#{Environ.test_environment.to_s.upcase} - #{ENV['TEST_CONTEXT']}"
629
741
  else
630
742
  Environ.test_environment.to_s.upcase
631
743
  end
632
- if ENV['PARALLEL']
744
+ if Environ.parallel
633
745
  thread_num = ENV['TEST_ENV_NUMBER']
634
746
  thread_num = 1 if thread_num.blank?
635
747
  context_message = "#{context_message} - Thread ##{thread_num}"
@@ -637,9 +749,25 @@ module TestCentricity
637
749
  context_message
638
750
  end
639
751
 
640
- def self.register_remote_driver(driver, browser, options)
641
- Capybara.register_driver driver do |app|
642
- capabilities = Selenium::WebDriver::Remote::Capabilities.send(browser.gsub(/\s+/, '_').downcase.to_sym, options)
752
+ def self.driver_name
753
+ unless Environ.driver_name
754
+ driver = case Environ.driver
755
+ when :webdriver
756
+ :local
757
+ when :selenium_grid, :grid
758
+ :remote
759
+ else
760
+ Environ.driver
761
+ end
762
+ Environ.driver_name = "#{driver}_#{Environ.browser}".downcase.to_sym unless driver.nil?
763
+ end
764
+ Environ.driver_name
765
+ end
766
+
767
+ def self.register_remote_driver(browser, options)
768
+ Capybara.register_driver driver_name do |app|
769
+ browser = browser.gsub(/\s+/, '_').downcase.to_sym if browser.is_a?(String)
770
+ capabilities = Selenium::WebDriver::Remote::Capabilities.new(options)
643
771
  Capybara::Selenium::Driver.new(app,
644
772
  browser: :remote,
645
773
  url: @endpoint,
@@ -648,7 +776,8 @@ module TestCentricity
648
776
 
649
777
  Environ.browser = browser
650
778
 
651
- Capybara.default_driver = driver
779
+ Capybara.default_driver = Environ.driver_name
780
+ Capybara.current_driver = Environ.driver_name
652
781
  Capybara.run_server = false
653
782
  end
654
783
 
@@ -660,6 +789,5 @@ module TestCentricity
660
789
  str if File.exist?(str)
661
790
  end
662
791
  end
663
- # :nocov:
664
792
  end
665
793
  end