Class: Scoutui::Commands::Strategy

Inherits:
Object
  • Object
show all
Defined in:
lib/scoutui/commands/strategy.rb

Constant Summary collapse

USER_AGENTS = 
{
    'MAC_CHROME' => 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/54.0.2840.98 Safari/537.36',
    'WIN81_IE11' => 'Mozilla/5.0 (Windows NT 6.3; Trident/7.0; rv 11.0) like Gecko',
    'WIN7_IE10'  => 'Mozilla/5.0 (compatible; MSIE 10.0; Windows NT 6.1; WOW64; Trident/6.0)',
    'WIN10_EDGE13' => '#Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/46.0.2486.0 Safari/537.36 Edge/13.10586',
    'WIN10_CHROME_BETA' => 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/56.0.2924.21 Safari/537.36',
    'YOSE_CHROME_BETA'  => 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/54.0.2840.98 Safari/537.36'
}

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(opts = nil) ⇒ Strategy

Returns a new instance of Strategy.



125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
 
# File 'lib/scoutui/commands/strategy.rb', line 125

def initialize(opts=nil)

  Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Scoutui::Commands.initialize(#{opts})"
  @profile=nil
  browserType = Scoutui::Base::UserVars.instance.getBrowserType()
  caps = Scoutui::Utils::TestUtils.instance.getCapabilities()

  ##
  # If running on Sauce, we need the capabilities.
  ##
  if Scoutui::Utils::TestUtils.instance.sauceEnabled?

    caps = Scoutui::Utils::TestUtils.instance.getSauceCaps()

    caps = Scoutui::Utils::TestUtils.instance.getCapabilities() if caps.nil?

    client=nil
    proxy=nil

    Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Capabilities => #{caps.to_s}"

    if caps.nil?

      caps = {
          :platform => "Mac OS X 10.9",
          :browserName => "chrome",
          :version => "beta",
          :full_description => 'Rover Test'
      }

    elsif caps.has_key?(:platform) && caps[:platform].match(/os x/i)
      tmpCaps = caps

      if caps.has_key?(:deviceName) && caps[:deviceName].match(/iphone/i)
        caps = Selenium::WebDriver::Remote::Capabilities.iphone()
      elsif caps.has_key?(:browser) && caps[:browser].match(/chrome/i)
        caps = Selenium::WebDriver::Remote::Capabilities.chrome()
      elsif caps.has_key?(:browser) && caps[:browser].match(/firefox/i)
        caps = Selenium::WebDriver::Remote::Capabilities.firefox()
      elsif caps.has_key?(:browser) && caps[:browser].match(/safari/i)
        caps = Selenium::WebDriver::Remote::Capabilities.safari()
      end

      tmpCaps.each_pair do |k, v|
        caps[k.to_s]=v
      end


    elsif caps.has_key?(:platform) && caps[:platform].match(/windows/i)
      tmpCaps = caps

      if caps.has_key?(:browser) && caps[:browser].match(/edge/i)

        Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Capabilities[browser] : EDGE"


        # https://support.saucelabs.com/customer/portal/questions/16217472-microsoft-edge-ruby-bindings
        if caps.has_key?(:browserName)
          Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Ruby bindings workaround for Edge"
          caps={}
        else
          Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " edge()"
          caps = Selenium::WebDriver::Remote::Capabilities.edge()
        end


      elsif caps.has_key?(:browser) && caps[:browser].match(/chrome/i)
        caps = Selenium::WebDriver::Remote::Capabilities.chrome()
      elsif caps.has_key?(:browser) && caps[:browser].match(/firefox/i)
        caps = Selenium::WebDriver::Remote::Capabilities.firefox()
      else
        caps = Selenium::WebDriver::Remote::Capabilities.internet_explorer()
      end

      tmpCaps.each_pair do |k, v|
        Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " caps[#{k.to_s}] = #{v}"
        caps[k.to_s]=v
      end


      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Remote Caps => #{caps.to_s}"

    elsif caps.has_key?(:deviceName) && caps[:deviceName].match(/(iphone|ipad)/i) && !caps[:deviceName].match(/simulator/i)
      caps = Selenium::WebDriver::Remote::Capabilities.iphone()
      caps['platform'] = 'OS X 10.10'
      caps['version'] = '9.1'
      caps['deviceName'] = 'iPhone 6 Plus'
      caps['deviceOrientation'] = 'portrait'

      if caps['deviceName'].match(/iphone/i)
        client = Selenium::WebDriver::Remote::Http::Default.new
        client.timeout = 360 # seconds – default is 60
      end

    elsif caps.has_key?(:deviceName) && caps[:deviceName].match(/(iphone|ipad)/i) && caps[:deviceName].match(/simulator/i)

      proxyVal = "localhost:8080"

      proxy = Selenium::WebDriver::Proxy.new(
          :http     => proxyVal,
          :ftp      => proxyVal,
          :ssl      => proxyVal
      )

      tmpCaps = caps

      caps = Selenium::WebDriver::Remote::Capabilities.iphone(:proxy => proxy)

      tmpCaps.each_pair do |k, v|
        caps[k.to_s]=v
      end

      client = Selenium::WebDriver::Remote::Http::Default.new
      client.timeout = 360 # seconds – default is 60

    end

    Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Capabilities => #{caps.to_s}"

    sauce_endpoint = "http://#{ENV['SAUCE_USERNAME']}:#{ENV['SAUCE_ACCESS_KEY']}@ondemand.saucelabs.com:80/wd/hub"

    if Scoutui::Utils::TestUtils.instance.getSauceTunnel()
      caps[:tunnelIdentifier]=Scoutui::Utils::TestUtils.instance.getSauceTunnel()
      puts __FILE__ + (__LINE__).to_s + " TunnelID: #{caps[:tunnelIdentifier]}"
    end

    begin
      if client.nil?
        Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " caps => #{caps}"
        @drv=Selenium::WebDriver.for :remote, :url => sauce_endpoint, :desired_capabilities => caps # setup(caps)
      else
        @drv=Selenium::WebDriver.for :remote, :url => sauce_endpoint, :http_client => client, :desired_capabilities => caps # setup(caps)
      end

    rescue => ex
      Scoutui::Logger::LogMgr.instance.debug "Error during processing: #{$!}"
      Scoutui::Logger::LogMgr.instance.debug "Backtrace:\n\t#{ex.backtrace.join("\n\t")}"
    end

    # The following print to STDOUT is useful when running on JENKINS with SauceLabs plugin
    # Reference:
    #   https://wiki.saucelabs.com/display/DOCS/Setting+Up+Reporting+between+Sauce+Labs+and+Jenkins
    puts "SauceOnDemandSessionID=#{@drv.session_id} job-name=#{caps[:name]}"


  elsif isHeadlessCap?(caps) || isHeadlessBrowser?(browserType)

    Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Headless browser : <caps, browser>::<#{caps}, #{browserType}>"

    _cap=Selenium::WebDriver::Remote::Capabilities.phantomjs('phantomjs.page.settings.userAgent' => USER_AGENTS['YOSE_CHROME_BETA'])


    selenium_server=Scoutui::Utils::TestUtils.instance.getSeleniumServer()

#        selenium_server='http://localhost:8001' if selenium_server.nil?

    if isHeadlessCap?(caps) && caps.has_key?(:useragent)
      _cap=Selenium::WebDriver::Remote::Capabilities.phantomjs('phantomjs.page.settings.userAgent' => caps[:useragent])
    end

    Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Headless capabilities : #{_cap}"

    _connected=false
    _tm={:start => Time.now, :end => nil }
    begin
      if !selenium_server.nil?
        @drv=Selenium::WebDriver.for :remote, :url => selenium_server, :desired_capabilities => _cap
      else
        @drv=Selenium::WebDriver.for :phantomjs
        #@drv=Selenium::WebDriver.for :remote, :desired_capabilities => _cap
      end

      _tm[:end]=Time.now
      _connected=true
      setViewport()

    rescue Errno::ECONNREFUSED => ex
      Scoutui::Logger::LogMgr.instance.fatal __FILE__ + (__LINE__).to_s + " Unable to connect to GhostDriver"

      Scoutui::Utils::TestUtils.instance.setState(:abort, __FILE__ + (__LINE__).to_s + " Unable to connect to GhostDriver : #{ex.class.to_s}: #{ex}")

    rescue => ex
      Scoutui::Utils::TestUtils.instance.setState(:abort, __FILE__ + (__LINE__).to_s + " : #{ex.class.to_s}: #{ex}")
      Scoutui::Logger::LogMgr.instance.warn __FILE__ + (__LINE__).to_s + " #{ex.class.to_s} Error during processing: #{ex}"
      Scoutui::Logger::LogMgr.instance.warn ex.backtrace
    end

    _tm[:end]=Time.now if _tm[:end].nil?

    Testmgr::TestReport.instance.getReq('Execution').tc('Status').add(_connected, "Connect to GhostDriver on #{selenium_server}", _tm[:end] - _tm[:start])


  else
    Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Create WebDriver: #{browserType.to_s}"

    if @profile.nil?
      @drv=Selenium::WebDriver.for browserType.to_sym
    else
      @drv=Selenium::WebDriver.for browserType.to_sym, :profile => @profile
    end

    setViewport()

  end


  if opts.is_a?(Hash) && !opts.has_key?(:loadModel).nil?
    loadModel(opts[:loadModel])
  end

end

Instance Attribute Details

#drv ⇒ Object

Returns the value of attribute drv.



17
18
19
 
# File 'lib/scoutui/commands/strategy.rb', line 17

def drv
  @drv
end

#profile ⇒ Object

Returns the value of attribute profile.



18
19
20
 
# File 'lib/scoutui/commands/strategy.rb', line 18

def profile
  @profile
end

Instance Method Details

#getDriver ⇒ Object 



20
21
22
 
# File 'lib/scoutui/commands/strategy.rb', line 20

def getDriver()
  @drv
end

#isHeadlessBrowser?(browserType) ⇒ Boolean

Returns:

  • (Boolean) 


42
43
44
 
# File 'lib/scoutui/commands/strategy.rb', line 42

def isHeadlessBrowser?(browserType)
  !browserType.match(/(phantom|phantomjs|ghost|ghostdriver)/i).nil?
end

#isHeadlessCap?(caps) ⇒ Boolean

Returns:

  • (Boolean) 


46
47
48
 
# File 'lib/scoutui/commands/strategy.rb', line 46

def isHeadlessCap?(caps)
  !caps.nil? && caps.has_key?(:browser) && isHeadlessBrowser?(caps[:browser])
end

#loadModel(f) ⇒ Object 



24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
 
# File 'lib/scoutui/commands/strategy.rb', line 24

def loadModel(f)
  rc=true
  begin
    rc=Scoutui::Utils::TestUtils.instance.loadModel(f)
  rescue => ex
    rc=false
    Scoutui::Logger::LogMgr.instance.fatal __FILE__ + (__LINE__).to_s + " loadModel(#{f}) => Failed"
  end

  Testmgr::TestReport.instance.getReq("ScoutUI").testcase('Setup').add(rc, "Verify load model #{f}.")

  if !rc
    Scoutui::Utils::TestUtils.instance.setState(:abort, "Failed to load model file #{f}.")
  end

  rc
end

#navigate(url) ⇒ Object 



58
59
60
61
62
63
64
65
66
67
68
69
70
 
# File 'lib/scoutui/commands/strategy.rb', line 58

def navigate(url)
  Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " [enter]:navigate(#{url})"
  rc = false
  begin
    processCommand('navigate(' + url + ')', nil)
    rc=true
  rescue => ex
    Scoutui::Logger::LogMgr.instance.warn "Error during processing: #{$!}"
    Scoutui::Logger::LogMgr.instance.warn "Backtrace:\n\t#{ex.backtrace.join("\n\t")}"
  end

  rc
end

#processCommand(_action, e = nil) ⇒ Object 



112
113
114
115
 
# File 'lib/scoutui/commands/strategy.rb', line 112

def processCommand(_action, e=nil)
  Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " [enter]:processCommand(#{_action})"
  Scoutui::Commands::processCommand(_action, e, getDriver())
end

#processCommands(cmds) ⇒ Object 



108
109
110
 
# File 'lib/scoutui/commands/strategy.rb', line 108

def processCommands(cmds)
  Scoutui::Commands::processCommands(cmds, getDriver())
end

#quit ⇒ Object 



77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
 
# File 'lib/scoutui/commands/strategy.rb', line 77

def quit()

  begin
    Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " quit()"


    Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " ===== Page Coverage ====="
    Scoutui::Utils::TestUtils.instance.getPageCoverage().each do |_c|
      Scoutui::Logger::LogMgr.instance.debug "   #{_c}"
    end

    metrics=Testmgr::TestReport.instance.getMetrics()
    Scoutui::Logger::LogMgr.instance.info "Metrics => #{metrics}"

    if Scoutui::Utils::TestUtils.instance.sauceEnabled?
      job_id = @drv.session_id

      SauceWhisk::Jobs.change_status job_id, metrics[:rc]

      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Update Sauce tests with job_id #{job_id} to #{metrics[:rc]}"
    end

  rescue => ex
    Scoutui::Logger::LogMgr.instance.warn "Error during processing: #{$!}"
    Scoutui::Logger::LogMgr.instance.warn "Backtrace:\n\t#{ex.backtrace.join("\n\t")}"
  end


  @drv.quit()
end

#report ⇒ Object 



72
73
74
75
 
# File 'lib/scoutui/commands/strategy.rb', line 72

def report()
  Testmgr::TestReport.instance.report()
#      Testmgr::TestReport.instance.generateReport()
end

#setup(dut) ⇒ Object 



117
118
119
120
121
122
123
 
# File 'lib/scoutui/commands/strategy.rb', line 117

def setup(dut)
  caps                      = Selenium::WebDriver::Remote::Capabilities.send(dut[:browserName])
  caps.version              = dut[:version]
  caps.platform             = dut[:platform]
  caps[:name]               = dut[:full_description]
  caps
end

#setViewport ⇒ Object 



50
51
52
53
54
55
56
 
# File 'lib/scoutui/commands/strategy.rb', line 50

def setViewport()
  _viewport = Scoutui::Utils::TestUtils.instance.getViewPort()
  if !_viewport.nil?
    target_size = Selenium::WebDriver::Dimension.new(_viewport[:width], _viewport[:height])
    getDriver().manage.window.size = target_size
  end
end